react-cheminfo 0.64.1 → 0.66.0

package/src/ir/core/irFormat.ts

@@ -6,6 +6,8 @@
  * row that calls it 1714.6 read as two bands.
  */
 
+import { formatTrimmed } from '../../format/core/numbers.ts';
+
 import type { IrMode } from './irSpectrum.ts';
 
 /** How many decimals an absorbance is written to. */
@@ -14,6 +16,9 @@ export const ABSORBANCE_DECIMALS = 3;
 /** How many a percent transmittance is written to. */
 export const TRANSMITTANCE_DECIMALS = 1;
 
+/** How many significant digits an intensity is written to. */
+export const INTENSITY_DIGITS = 4;
+
 /**
  * Write a wavenumber the way a chemist quotes one.
  *
@@ -35,23 +40,51 @@ export function formatWavenumber(wavenumber: number): string {
  * Three decimals for an absorbance and one for a percent transmittance, which is
  * roughly the same precision expressed two ways — an absorbance of 0.001 and a
  * transmittance of 0.2 percent are both about where a real spectrum's noise
- * sits.
+ * sits. An intensity is counts from one instrument and a fraction of the
+ * strongest band from another, so no count of decimals suits it: it keeps
+ * `INTENSITY_DIGITS` significant digits instead.
  * @param value - The value.
  * @param mode - Which axis it is in.
  * @returns The number as a string, without its unit.
  */
 export function formatIrValue(value: number, mode: IrMode): string {
   if (!Number.isFinite(value)) return '';
-  return value.toFixed(
-    mode === 'absorbance' ? ABSORBANCE_DECIMALS : TRANSMITTANCE_DECIMALS,
-  );
+  const { decimals } = VALUE_FORMATS[mode];
+  return decimals === undefined
+    ? formatTrimmed(value, { significant: INTENSITY_DIGITS })
+    : value.toFixed(decimals);
 }
 
 /**
  * What the value axis is called where there is room for one word.
  * @param mode - Which axis is being drawn.
- * @returns `A` or `%T`, as a spectrum is annotated by hand.
+ * @returns `A`, `%T` or `I`, as a spectrum is annotated by hand.
  */
 export function shortModeLabel(mode: IrMode): string {
-  return mode === 'absorbance' ? 'A' : '%T';
+  return VALUE_FORMATS[mode].symbol;
 }
+
+/**
+ * The range a spectrum covers, written in the order its axis is read.
+ * @param wavenumbers - Its wavenumbers, ascending.
+ * @param reversed - Whether the axis runs from high to low, as infrared's does.
+ * @returns `4000–400 cm⁻¹` on a reversed axis, `100–3200 cm⁻¹` on one that is
+ * not, and an empty string for a spectrum with no point.
+ */
+export function formatWavenumberRange(
+  wavenumbers: Float64Array,
+  reversed: boolean,
+): string {
+  const lowest = wavenumbers[0];
+  const highest = wavenumbers.at(-1);
+  if (lowest === undefined || highest === undefined) return '';
+  const [first, last] = reversed ? [highest, lowest] : [lowest, highest];
+  return `${formatWavenumber(first)}–${formatWavenumber(last)} cm⁻¹`;
+}
+
+/** How each value axis is written: its symbol, and its count of decimals. */
+const VALUE_FORMATS: Record<IrMode, { symbol: string; decimals?: number }> = {
+  transmittance: { symbol: '%T', decimals: TRANSMITTANCE_DECIMALS },
+  absorbance: { symbol: 'A', decimals: ABSORBANCE_DECIMALS },
+  intensity: { symbol: 'I' },
+};

package/src/ir/core/irMode.ts

@@ -1,14 +1,14 @@
 /**
- * Everything that differs between reading a spectrum as absorbance and reading
- * it as percent transmittance.
+ * Everything that differs between reading a spectrum as absorbance, as percent
+ * transmittance, or — for a Raman spectrum — as intensity.
  *
- * The two are the same measurement drawn upside down, and nearly every
+ * The first two are the same measurement drawn upside down, and nearly every
  * difference between them is one of a handful of facts: what the axis is called,
  * where its baseline is, whether that baseline is held in the window, which way
  * a band points, and which zoom gestures are worth answering. Gathering them
  * here is what keeps the switch from being an `if (mode === …)` in the chart,
  * the tracker, the band marks, the zoom and the fitting separately, where they
- * would eventually disagree.
+ * would eventually disagree. Intensity is one more entry of the same facts.
  *
  * **No conversion happens here, or anywhere in this package.** `ir-spectrum`
  * adds both an absorbance and a transmittance variable to every spectrum it
@@ -24,9 +24,14 @@ import type {
 } from '../../chart/core/chartDomain.ts';
 
 import type { IrMode } from './irSpectrum.ts';
+import type { IrTechnique } from './irTechnique.ts';
+import { IR_TECHNIQUE_RULES, irModeTechnique } from './irTechnique.ts';
 
-/** The two ways a spectrum is read, in the order a control offers them. */
-export const IR_MODES: readonly IrMode[] = ['transmittance', 'absorbance'];
+/**
+ * The two ways an infrared spectrum is read, in the order a control offers
+ * them.
+ */
+export const IR_MODES: readonly IrMode[] = IR_TECHNIQUE_RULES.infrared.modes;
 
 /**
  * How each mode behaves, every fact in one place.
@@ -115,6 +120,22 @@ export const IR_MODE_RULES = {
      */
     wheelZoom: true,
   },
+  intensity: {
+    title: 'intensity',
+    /** No light scattered is a real floor, as no light absorbed is. */
+    baseline: 0,
+    /** Not held in a dragged window, for the reason absorbance gives. */
+    keepBaseline: false,
+    /** A Raman band stands up out of the baseline under it. */
+    bandsPointDown: false,
+    /**
+     * Both drags are worth having: intensity is open at the top and its weak
+     * bands lie against zero, as absorbance's do.
+     */
+    boxZoomOnly: false,
+    /** The wheel scales the axis about zero, bringing a weak band up. */
+    wheelZoom: true,
+  },
 } as const satisfies Record<
   IrMode,
   {
@@ -199,10 +220,21 @@ export function bandsPointDown(mode: IrMode): boolean {
 }
 
 /**
- * The other mode, for a control that toggles between the two.
+ * The next mode, for a control that toggles between them.
+ *
+ * It never leaves the technique: an infrared viewer goes back and forth
+ * between its two axes, and a Raman one, reading intensity alone, stays where
+ * it is.
  * @param mode - The mode in force.
- * @returns The one to switch to.
+ * @param technique - The technique whose modes are toggled through. Defaults to
+ * the one that reads `mode`.
+ * @returns The one to switch to: the technique's first when `mode` is not one
+ * of its own.
  */
-export function otherIrMode(mode: IrMode): IrMode {
-  return mode === 'absorbance' ? 'transmittance' : 'absorbance';
+export function otherIrMode(
+  mode: IrMode,
+  technique: IrTechnique = irModeTechnique(mode),
+): IrMode {
+  const modes: readonly IrMode[] = IR_TECHNIQUE_RULES[technique].modes;
+  return modes[(modes.indexOf(mode) + 1) % modes.length] ?? mode;
 }

package/src/ir/core/irReducer.ts

@@ -16,12 +16,7 @@
 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';
+import { isIrWindow, mergeIrSettings } from './irState.ts';
 
 /** Everything that can be asked of the viewer. */
 export type IrAction =
@@ -41,49 +36,6 @@ export type IrAction =
   | { 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.

package/src/ir/core/irSpectrum.ts

@@ -1,17 +1,22 @@
 /**
- * What an infrared spectrum is once it has been read, whatever it was read from.
+ * What a vibrational 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.
+ * One infrared 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.
+ *
+ * A Raman acquisition carries its intensity instead, over its Raman shifts —
+ * also wavenumbers in cm⁻¹ — and neither infrared axis: there is no
+ * transmittance of scattered light to convert it to.
  *
  * The arrays are `Float64Array` and are replaced on a change, never written
- * into, since every consumer holds the same object by reference. An infrared
+ * into, since every consumer holds the same object by reference. A vibrational
  * spectrum is a few thousand points rather than a mass spectrum's few hundred
  * thousand, so holding two value axes costs nothing worth counting.
  */
@@ -30,8 +35,11 @@ import type { ChartDomain } from '../../chart/core/chartDomain.ts';
  */
 export type IrTrace = DataXY<Float64Array>;
 
-/** The formats a spectrum can have been read from. */
-export type IrFormat = 'jcamp' | 'spc' | 'text' | 'calculated';
+/**
+ * The formats a spectrum can have been read from. `wdf` is Renishaw's Raman
+ * format, which a host reads with its own parser and hands over.
+ */
+export type IrFormat = 'jcamp' | 'spc' | 'text' | 'wdf' | 'calculated';
 
 /**
  * Where a spectrum came from, and what the file said about the acquisition.
@@ -87,8 +95,11 @@ export interface IrMeta {
   fields: IrMetaField[];
 }
 
-/** Which value axis is being drawn and read. */
-export type IrMode = 'absorbance' | 'transmittance';
+/**
+ * Which value axis is being drawn and read: absorbance or percent
+ * transmittance for an infrared spectrum, intensity for a Raman one.
+ */
+export type IrMode = 'absorbance' | 'transmittance' | 'intensity';
 
 /** One spectrum as the viewer holds it. */
 export interface IrSpectrum {
@@ -99,19 +110,33 @@ export interface IrSpectrum {
   /** The colour it is drawn in. */
   color: string;
   /**
-   * The wavenumbers in cm⁻¹, **ascending**.
+   * The wavenumbers in cm⁻¹, **ascending** — of the light absorbed for an
+   * infrared spectrum, the Raman shift for a Raman one.
    *
-   * 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.
+   * Ascending even though the infrared 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;
+  /**
+   * Absorbance at each wavenumber, as `ir-spectrum` supplied it. An infrared
+   * spectrum carries it beside `transmittance`.
+   * @default undefined
+   */
+  absorbance?: Float64Array;
+  /**
+   * Percent transmittance at each wavenumber, likewise.
+   * @default undefined
+   */
+  transmittance?: Float64Array;
+  /**
+   * Intensity at each Raman shift, which a Raman spectrum carries instead of
+   * the two infrared axes.
+   * @default undefined
+   */
+  intensity?: Float64Array;
   /** What the file said about the acquisition, `null` when it said nothing. */
   meta: IrMeta | null;
   /** Where it came from. */
@@ -145,11 +170,15 @@ export type IrDomain = ChartDomain;
  * 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.
+ * @returns The trace, sharing the spectrum's own arrays, or `undefined` when the
+ * spectrum carries no such axis — a Raman spectrum has no absorbance.
  */
-export function traceOf(spectrum: IrSpectrum, mode: IrMode): IrTrace {
-  return {
-    x: spectrum.wavenumber,
-    y: mode === 'absorbance' ? spectrum.absorbance : spectrum.transmittance,
-  };
+export function traceOf(
+  spectrum: IrSpectrum,
+  mode: IrMode,
+): IrTrace | undefined {
+  const values = spectrum[mode];
+  return values === undefined
+    ? undefined
+    : { x: spectrum.wavenumber, y: values };
 }

package/src/ir/core/irState.ts

@@ -15,6 +15,8 @@
 
 import type { IrSidePanelId } from './irSidePanels.ts';
 import type { IrDomain, IrMode, IrSpectrum } from './irSpectrum.ts';
+import type { IrTechnique } from './irTechnique.ts';
+import { defaultIrMode, irModeFor, offersIrMode } from './irTechnique.ts';
 import type { PickBandsOptions } from './pickBands.ts';
 
 /** The document: what a file holds. */
@@ -48,7 +50,12 @@ export interface IrView {
 
 /** The workspace: how every spectrum is drawn, whichever ones are open. */
 export interface IrSettings {
-  /** Which value axis the spectra are read in. */
+  /**
+   * What the spectra were measured with. Chosen when the viewer opens and fixed
+   * from then on: a change asking for another is ignored.
+   */
+  technique: IrTechnique;
+  /** Which value axis the spectra are read in, always one the technique offers. */
   mode: IrMode;
   /** Whether the bands are picked at all. */
   pickBands: boolean;
@@ -108,6 +115,7 @@ export const DEFAULT_PICKING: PickBandsOptions = {
 
 /** The workspace a fresh viewer starts from. */
 export const DEFAULT_SETTINGS: IrSettings = {
+  technique: 'infrared',
   mode: 'transmittance',
   pickBands: true,
   picking: DEFAULT_PICKING,
@@ -116,6 +124,57 @@ export const DEFAULT_SETTINGS: IrSettings = {
   assignmentTolerance: 5,
 };
 
+/** What a viewer opens on. */
+export interface CreateIrStateOptions {
+  /**
+   * The spectra to open on.
+   * @default []
+   */
+  spectra?: IrSpectrum[];
+  /**
+   * The workspace to open in. Its `technique` is fixed for the life of the
+   * viewer, and its `mode` falls back to the technique's first when the
+   * technique does not offer it.
+   * @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;
+  const technique = settings?.technique ?? DEFAULT_SETTINGS.technique;
+  const opened: IrSettings = {
+    ...DEFAULT_SETTINGS,
+    technique,
+    mode: defaultIrMode(technique),
+  };
+  return {
+    data: { spectra: [...spectra] },
+    view: {
+      selectedId: spectra[0]?.id ?? null,
+      domain: null,
+      tool: 'read',
+      openPanelIds: [...(panelIds ?? DEFAULT_SIDE_PANELS)],
+      error: null,
+    },
+    settings: mergeIrSettings(opened, settings),
+  };
+}
+
 /**
  * Fold a change into the workspace, refusing what no chart survives.
  *
@@ -123,7 +182,9 @@ export const DEFAULT_SETTINGS: IrSettings = {
  * 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.
+ * fought with while it is being typed in. The technique is never changed, and a
+ * mode it does not offer is refused the same way: a Raman spectrum has no
+ * absorbance to draw.
  * @param current - The workspace in force.
  * @param change - What to change about it.
  * @returns The new workspace.
@@ -137,6 +198,10 @@ export function mergeIrSettings(
   return {
     ...current,
     ...change,
+    technique: current.technique,
+    mode: offersIrMode(current.technique, change.mode)
+      ? change.mode
+      : irModeFor(current.technique, current.mode),
     picking: { ...current.picking, ...change.picking },
     labelLimit: Number.isFinite(asked)
       ? Math.min(MAXIMUM_LABEL_LIMIT, Math.max(0, Math.round(asked)))

package/src/ir/core/irTechnique.ts

@@ -0,0 +1,115 @@
+/**
+ * Everything that differs between an infrared spectrum and a Raman one.
+ *
+ * Both are vibrational spectra over wavenumbers in cm⁻¹, and the viewer reads
+ * them the same way — one chart, one set of panels, one set of gestures — so
+ * what is left to differ is a handful of facts: which value axes a spectrum is
+ * read on, what the horizontal axis is called and which way it runs, whether the
+ * correlation table has anything to say about a band, and what a written file
+ * calls itself. They are gathered here for the reason `IR_MODE_RULES` gathers
+ * what differs between the value axes: a component that asked which technique
+ * it was drawing would be the first of many to ask, and they would come to
+ * disagree.
+ */
+
+import type { IrMode } from './irSpectrum.ts';
+
+/** What was measured: the light a sample absorbs, or the light it scatters. */
+export type IrTechnique = 'infrared' | 'raman';
+
+/** What is true of one technique. */
+export interface IrTechniqueRules {
+  /** How it is written inside a sentence; a sentence opening on it capitalises it. */
+  name: string;
+  /** The value axes a spectrum is read on, in the order a control offers them. */
+  modes: readonly IrMode[];
+  /** What the horizontal axis is called. */
+  xTitle: string;
+  /** Whether the horizontal axis runs from high at the left to low at the right. */
+  reverseX: boolean;
+  /** Whether the correlation table is asked what a band might be. */
+  assignments: boolean;
+  /** The `##DATA TYPE=` a written spectrum states when its file stated none. */
+  dataType: string;
+}
+
+/** The techniques, in the order a control would offer them. */
+export const IR_TECHNIQUES: readonly IrTechnique[] = ['infrared', 'raman'];
+
+/** How each technique behaves, every fact in one place. */
+export const IR_TECHNIQUE_RULES = {
+  infrared: {
+    name: 'infrared',
+    modes: ['transmittance', 'absorbance'],
+    xTitle: 'wavenumber (cm⁻¹)',
+    /**
+     * 4000 at the left and 400 at the right, which is how every infrared
+     * spectrum has been printed since the instruments scanned that way.
+     */
+    reverseX: true,
+    assignments: true,
+    dataType: 'INFRARED SPECTRUM',
+  },
+  raman: {
+    name: 'Raman',
+    /** One axis: a Raman spectrum is the light scattered, and nothing else. */
+    modes: ['intensity'],
+    xTitle: 'Raman shift (cm⁻¹)',
+    /** The shift grows away from the laser line, left to right. */
+    reverseX: false,
+    /**
+     * The table holds infrared group frequencies and infrared strengths. A
+     * vibration strong in one technique is often weak or silent in the other,
+     * so its candidates offered for a Raman band would claim what the table
+     * does not know.
+     */
+    assignments: false,
+    dataType: 'RAMAN SPECTRUM',
+  },
+} as const satisfies Record<IrTechnique, IrTechniqueRules>;
+
+/**
+ * The value axis a viewer of a technique opens on.
+ * @param technique - What was measured.
+ * @returns Its first mode.
+ */
+export function defaultIrMode(technique: IrTechnique): IrMode {
+  return IR_TECHNIQUE_RULES[technique].modes[0];
+}
+
+/**
+ * Whether a technique reads its spectra on a value axis.
+ * @param technique - What was measured.
+ * @param mode - The axis asked about; `undefined` is offered by none.
+ * @returns Whether the technique offers it.
+ */
+export function offersIrMode(
+  technique: IrTechnique,
+  mode: IrMode | undefined,
+): mode is IrMode {
+  if (mode === undefined) return false;
+  const modes: readonly IrMode[] = IR_TECHNIQUE_RULES[technique].modes;
+  return modes.includes(mode);
+}
+
+/**
+ * The value axis to read a technique's spectra on, given the one asked for.
+ * @param technique - What was measured.
+ * @param mode - The axis asked for, if any.
+ * @returns It when the technique offers it, the technique's first otherwise.
+ */
+export function irModeFor(technique: IrTechnique, mode?: IrMode): IrMode {
+  return offersIrMode(technique, mode) ? mode : defaultIrMode(technique);
+}
+
+/**
+ * The technique that reads its spectra on a value axis.
+ *
+ * Every axis belongs to exactly one technique, so the axis a file was written
+ * on says what was measured.
+ * @param mode - The value axis.
+ * @returns The technique offering it.
+ */
+export function irModeTechnique(mode: IrMode): IrTechnique {
+  return offersIrMode('raman', mode) ? 'raman' : 'infrared';
+}

package/src/ir/core/irTechniqueCommands.ts

@@ -0,0 +1,82 @@
+/**
+ * The commands each technique's viewer offers.
+ *
+ * A Raman viewer offers the infrared table less the commands with nothing to
+ * act on — one value axis is nothing to toggle, and no assignment is nothing to
+ * name — and words the rest without the absorbance and transmittance it does
+ * not have. It is built from the infrared table, so a command added there
+ * reaches both.
+ */
+
+import type { IrCommand, IrCommandId, IrCommandTable } from './irCommands.ts';
+import { irCommands } from './irCommands.ts';
+import type { IrTechnique } from './irTechnique.ts';
+import { IR_TECHNIQUE_RULES } from './irTechnique.ts';
+
+/**
+ * Whether a viewer of a technique offers a command at all.
+ * @param technique - What was measured.
+ * @param id - Which command.
+ * @returns False for the toggle of a technique with one value axis, and for
+ * the assignments of one the correlation table says nothing about.
+ */
+export function irCommandOffered(
+  technique: IrTechnique,
+  id: IrCommandId,
+): boolean {
+  const { modes, assignments } = IR_TECHNIQUE_RULES[technique];
+  if (id === 'toggleMode') return modes.length > 1;
+  if (id === 'toggleAssignments') return assignments;
+  return true;
+}
+
+/**
+ * Everything a viewer of a technique offers, in the order it is reached for.
+ * @param technique - What was measured.
+ * @returns The table; for infrared, `irCommands` itself.
+ */
+export function irCommandsFor(technique: IrTechnique): IrCommandTable {
+  return COMMAND_TABLES[technique];
+}
+
+/** Where the chart is, for a gesture made anywhere on it. */
+const OVER_THE_CHART = 'Over the chart';
+
+/** How a Raman viewer words the commands it shares with infrared. */
+const RAMAN_WORDING: Partial<Record<IrCommandId, Partial<IrCommand>>> = {
+  about: { title: 'About the Raman viewer' },
+  documentation: {
+    description: 'How the bands are read, and every gesture.',
+  },
+  readTool: {
+    description:
+      'A drag narrows the Raman shift axis. Released past the baseline, it takes the intensity axis with it.',
+    gestures: [{ title: OVER_THE_CHART, shortcuts: ['Drag'] }],
+  },
+  boxTool: {
+    description:
+      'A drag zooms to exactly the rectangle it sweeps out, both axes at once — for looking into a baseline or a shoulder rather than across the spectrum.',
+  },
+  zoomIn: {
+    description:
+      'Brings the weak bands up, scaling the intensity axis about zero.',
+    gestures: [{ title: OVER_THE_CHART, shortcuts: ['Scroll wheel'] }],
+  },
+  zoomOut: {
+    gestures: [{ title: OVER_THE_CHART, shortcuts: ['Scroll wheel'] }],
+  },
+  togglePicking: {
+    description:
+      'Finds the bands of the selected spectrum, marks them on the chart and lists them.',
+  },
+};
+
+/** The command table of each technique. */
+const COMMAND_TABLES: Record<IrTechnique, IrCommandTable> = {
+  infrared: irCommands,
+  raman: Object.fromEntries(
+    (Object.keys(irCommands) as IrCommandId[])
+      .filter((id) => irCommandOffered('raman', id))
+      .map((id) => [id, { ...irCommands[id], ...RAMAN_WORDING[id] }]),
+  ),
+};