react-cheminfo 0.65.0 → 0.66.0

package/src/ir/ui/bandsTsv.ts

@@ -0,0 +1,46 @@
+/**
+ * The band table as text, for pasting into a notebook.
+ */
+
+import type { AssignedBand } from '../core/assignBands.ts';
+import { bandValue } from '../core/irBand.ts';
+import { formatIrValue, formatWavenumber } from '../core/irFormat.ts';
+import type { IrMode } from '../core/irSpectrum.ts';
+
+/**
+ * The table as tab separated text.
+ *
+ * Every candidate is on its band's row, because the reason to copy a band table
+ * is to put it beside a structure and argue about it — and the argument is over
+ * the candidates rather than over the wavenumbers. A technique the correlation
+ * table does not cover has no such column.
+ * @param rows - The bands, as they are shown.
+ * @param mode - Which value axis is being read.
+ * @param assignments - Whether the table has a column for the candidates.
+ * @returns The table, one line per band, with a heading.
+ */
+export function bandsToTsv(
+  rows: readonly AssignedBand[],
+  mode: IrMode,
+  assignments: boolean,
+): string {
+  const heading = ['wavenumber', 'strength', mode];
+  if (assignments) heading.push('could be');
+  const lines = [heading.join('\t')];
+  for (const { band, candidates } of rows) {
+    const cells = [
+      formatWavenumber(band.wavenumber),
+      band.strength,
+      formatIrValue(bandValue(band, mode) ?? Number.NaN, mode),
+    ];
+    if (assignments) {
+      cells.push(
+        candidates
+          .map((candidate) => `${candidate.group} ${candidate.vibration}`)
+          .join('; '),
+      );
+    }
+    lines.push(cells.join('\t'));
+  }
+  return lines.join('\n');
+}

package/src/ir/ui/irChartProps.ts

@@ -7,8 +7,9 @@
  * of half a dozen layers nobody needs to read in order to mount one.
  *
  * Everything arrives as a prop and nothing is reached for: the chart reads no
- * context and no store, so the same component serves an editor, a report page
- * that only ever draws one spectrum, and a test.
+ * store and no context but the language the page is written in, so the same
+ * component serves an editor, a report page that only ever draws one spectrum,
+ * and a test.
  */
 
 import type { ReactNode } from 'react';
@@ -17,17 +18,26 @@ import type { ZoomDragMode } from '../../chart/core/chartDomain.ts';
 import type { AssignedBand } from '../core/assignBands.ts';
 import type { IrBand } from '../core/irBand.ts';
 import type { IrDomain, IrMode, IrSpectrum } from '../core/irSpectrum.ts';
+import type { IrTechnique } from '../core/irTechnique.ts';
 
 export interface IrChartProps {
   /** The spectra to draw, each saying in itself whether it is drawn. */
   spectra: readonly IrSpectrum[];
   /**
-   * Which value axis to draw them in.
+   * What the spectra were measured with, which names the wavenumber axis and
+   * decides which way it runs: high to low for infrared, low to high for Raman.
+   * @default 'infrared'
+   */
+  technique?: IrTechnique;
+  /**
+   * Which value axis to draw them in. One the technique does not offer draws
+   * its first instead.
    *
    * A prop rather than state, so the switch lives with whoever owns the toolbar
    * that flips it — and so two charts of the same spectra can be shown side by
    * side, one in each, which is the clearest way to see what the pair means.
-   * @default 'transmittance'
+   * @default the technique's first: `'transmittance'` for infrared,
+   * `'intensity'` for Raman
    */
   mode?: IrMode;
   /**

package/src/ir/ui/irCommandContext.tsx

@@ -12,14 +12,18 @@ import type {
   IrCommandId,
   RunIrCommand,
 } from '../core/irCommands.ts';
-import { irCommandLabel } from '../core/irCommands.ts';
+import { irCommandEntryLabel, irCommands } from '../core/irCommands.ts';
+import type { IrTechnique } from '../core/irTechnique.ts';
 
 import { IrCommandTooltip } from './IrCommandTooltip.tsx';
+import { useIrText } from './useIrText.ts';
 
 /** What the provider holds. */
 export interface IrCommandContextValue {
   /** What each command does. */
   handlers: IrCommandHandlers;
+  /** What the spectra were measured with, which words the commands. */
+  technique: IrTechnique;
   /** Run one. */
   run: RunIrCommand;
 }
@@ -36,6 +40,14 @@ export function useIrCommand(): RunIrCommand {
   return value?.run ?? noRun;
 }
 
+/**
+ * What the spectra were measured with, from anywhere inside the viewer.
+ * @returns The technique; infrared outside a provider.
+ */
+export function useIrCommandTechnique(): IrTechnique {
+  return useContext(commandContext)?.technique ?? 'infrared';
+}
+
 /**
  * Everything a toolbar item needs to be one command, in one spread.
  *
@@ -46,10 +58,13 @@ export function useIrCommand(): RunIrCommand {
  */
 export function useIrCommandProps() {
   const run = useIrCommand();
+  const technique = useIrCommandTechnique();
+  const text = useIrText(technique);
   return function command(id: IrCommandId) {
+    const entry = text.command(id) ?? irCommands[id];
     return {
-      tooltip: <IrCommandTooltip id={id} />,
-      'aria-label': irCommandLabel(id),
+      tooltip: <IrCommandTooltip id={id} technique={technique} />,
+      'aria-label': irCommandEntryLabel(entry),
       onClick: () => run(id),
     };
   };

package/src/ir/ui/useIrEditor.ts

@@ -17,10 +17,13 @@ import { useEffect, useMemo, useReducer, useRef } from 'react';
 
 import type { AssignedBand } from '../core/assignBands.ts';
 import { assignBands } from '../core/assignBands.ts';
-import type { CreateIrStateOptions } from '../core/irReducer.ts';
-import { createIrState, irReducer } from '../core/irReducer.ts';
+import type { BandAssignment } from '../core/bandAssignments.ts';
+import { BAND_ASSIGNMENTS } from '../core/bandAssignments.ts';
+import { irReducer } from '../core/irReducer.ts';
 import type { IrSpectrum } from '../core/irSpectrum.ts';
-import type { IrState } from '../core/irState.ts';
+import type { CreateIrStateOptions, IrState } from '../core/irState.ts';
+import { createIrState } from '../core/irState.ts';
+import { IR_TECHNIQUE_RULES } from '../core/irTechnique.ts';
 import { pickBands } from '../core/pickBands.ts';
 
 import type { IrEditorActions } from './irActions.ts';
@@ -46,7 +49,8 @@ export interface IrEditorApi {
   selectedSpectrum: IrSpectrum | null;
   /**
    * The bands of the selected spectrum, with everything each might be. Empty
-   * while nothing is selected or while picking is switched off.
+   * while nothing is selected or while picking is switched off, and every band
+   * without a candidate for a technique the correlation table does not cover.
    */
   assigned: AssignedBand[];
   /** Everything to do. */
@@ -67,7 +71,7 @@ export function useIrEditor(options: UseIrEditorOptions = {}): IrEditorApi {
   const { spectra } = state.data;
   const { selectedId } = state.view;
   const { pickBands: picking, picking: pickingOptions } = state.settings;
-  const { assignmentTolerance } = state.settings;
+  const { assignmentTolerance, technique } = state.settings;
 
   const visibleSpectra = useMemo(() => {
     const visible: IrSpectrum[] = [];
@@ -95,10 +99,15 @@ export function useIrEditor(options: UseIrEditorOptions = {}): IrEditorApi {
 
   // Assigning is a walk of thirty ranges per band, which is nothing beside the
   // picking — so it is a memo of its own, and moving the tolerance does not
-  // re-pick.
+  // re-pick. A technique the table does not cover is matched against no table.
+  const { assignments } = IR_TECHNIQUE_RULES[technique];
   const assigned = useMemo(
-    () => assignBands(bands, { tolerance: assignmentTolerance }),
-    [bands, assignmentTolerance],
+    () =>
+      assignBands(bands, {
+        tolerance: assignmentTolerance,
+        assignments: assignments ? BAND_ASSIGNMENTS : NO_ASSIGNMENTS,
+      }),
+    [bands, assignmentTolerance, assignments],
   );
 
   // What was reported last, so a host passing a fresh callback on every render
@@ -118,6 +127,9 @@ export function useIrEditor(options: UseIrEditorOptions = {}): IrEditorApi {
   );
 }
 
+/** The table a technique the correlation table does not cover is matched against. */
+const NO_ASSIGNMENTS: readonly BandAssignment[] = [];
+
 /**
  * Whether two lists hold the same spectra, by identity and in order.
  * @param current - What was reported last.

package/src/ir/ui/useIrHandle.ts

@@ -0,0 +1,51 @@
+/**
+ * The handle a host drives the viewer through, filled in from its state.
+ *
+ * A hook of its own beside the shell, because every gesture on the handle reads
+ * the state the shell already reads — and the shell is long enough without it.
+ */
+
+import type { Ref } from 'react';
+import { useImperativeHandle } from 'react';
+
+import { fullDomain } from '../core/irDomain.ts';
+import type { IrEditorHandle, ZoomToBandOptions } from '../core/irEditorApi.ts';
+import type { IrDomain } from '../core/irSpectrum.ts';
+
+import { useIrActions, useIrEditorState } from './irStateContext.ts';
+
+/**
+ * Fill in a host's handle on the viewer this is called inside.
+ * @param handle - The handle to fill in, if the host asked for one.
+ */
+export function useIrHandle(handle: Ref<IrEditorHandle> | undefined): void {
+  const { state, visibleSpectra } = useIrEditorState();
+  const actions = useIrActions();
+  const { domain } = state.view;
+  const { mode } = state.settings;
+
+  useImperativeHandle(
+    handle,
+    (): IrEditorHandle => ({
+      getSpectra: () => state.data.spectra,
+      setSpectra: (spectra) => actions.setSpectra(spectra),
+      addSpectra: (spectra) => actions.addSpectra(spectra),
+      clear: () => actions.clear(),
+      setDomain: (next) => actions.setDomain(next),
+      resetDomain: () => actions.resetDomain(),
+      zoomToWavenumber: (wavenumber, options: ZoomToBandOptions = {}) => {
+        const { width = DEFAULT_FRAME_WIDTH } = options;
+        const shown: IrDomain = domain ?? fullDomain(visibleSpectra, mode);
+        actions.setDomain({
+          x: [wavenumber - width / 2, wavenumber + width / 2],
+          y: shown.y,
+        });
+      },
+      selectSpectrum: (id) => actions.selectSpectrum(id),
+    }),
+    [state.data.spectra, actions, domain, visibleSpectra, mode],
+  );
+}
+
+/** How wide a window a host gets when it asks to frame a band without saying. */
+const DEFAULT_FRAME_WIDTH = 200;

package/src/ir/ui/useIrText.ts

@@ -0,0 +1,170 @@
+/**
+ * The words of the viewer that change with what was measured, in the language
+ * the page is written in.
+ *
+ * Infrared's are not in the chrome's catalog: they are read from the core
+ * records, so an infrared viewer reads the same in every language. Raman's are
+ * in the catalog, each key written out rather than built, so a key the catalog
+ * lacks fails the type check instead of rendering raw.
+ */
+
+import type { ChromeKey } from '../../i18n/core/chromeCatalog.ts';
+import type { Translate } from '../../i18n/ui/useT.ts';
+import { useChromeT } from '../../i18n/ui/useT.ts';
+import type { IrCommand, IrCommandId } from '../core/irCommands.ts';
+import { boxZoomOnly, yAxisTitle } from '../core/irMode.ts';
+import type { IrMode } from '../core/irSpectrum.ts';
+import type { IrTechnique } from '../core/irTechnique.ts';
+import { IR_TECHNIQUE_RULES } from '../core/irTechnique.ts';
+import { irCommandsFor } from '../core/irTechniqueCommands.ts';
+
+/** The words that change with what was measured. */
+export interface IrText {
+  /** What the horizontal axis is called. */
+  xTitle: string;
+  /** What the value axis is called in a mode. */
+  yTitle: (mode: IrMode) => string;
+  /** What the chart is and what can be done to it, for whoever cannot see it. */
+  chart: (mode: IrMode) => string;
+  /** The accessible name of the tool rail. */
+  tools: string;
+  /** The accessible name of the header. */
+  viewer: string;
+  /** The accessible name of the header's help group. */
+  viewerHelp: string;
+  /** The accessible name of the mark. */
+  mark: string;
+  /** The title of the documentation dialog. */
+  documentation: string;
+  /** A command as the viewer words it, `undefined` for one it does not offer. */
+  command: (id: IrCommandId) => IrCommand | undefined;
+}
+
+/**
+ * The words of a viewer of one technique.
+ * @param technique - What was measured.
+ * @returns The words, in the language of the page where the catalog has them.
+ */
+export function useIrText(technique: IrTechnique): IrText {
+  const t = useChromeT();
+  return technique === 'raman' ? ramanText(t) : infraredText(t);
+}
+
+/**
+ * The words of an infrared viewer, from the core records.
+ * @param t - The chrome's formatter, for a value axis the catalog names.
+ * @returns The words.
+ */
+function infraredText(t: Translate<ChromeKey>): IrText {
+  const { name, xTitle } = IR_TECHNIQUE_RULES.infrared;
+  const opening = `${name.charAt(0).toUpperCase()}${name.slice(1)}`;
+  const commands = irCommandsFor('infrared');
+  return {
+    xTitle,
+    yTitle: (mode) => modeTitle(t, mode),
+    chart: (mode) => infraredChartLabel(opening, mode),
+    tools: `${opening} spectrum tools`,
+    viewer: `${opening} spectrum viewer`,
+    viewerHelp: `${opening} spectrum viewer help`,
+    mark: `${opening} viewer`,
+    documentation: `Using the ${name} viewer`,
+    command: (id) => commands[id],
+  };
+}
+
+/**
+ * The words of a Raman viewer, all of them from the catalog.
+ * @param t - The chrome's formatter.
+ * @returns The words.
+ */
+function ramanText(t: Translate<ChromeKey>): IrText {
+  const commands = irCommandsFor('raman');
+  return {
+    xTitle: t('ir.raman.xTitle'),
+    yTitle: (mode) => modeTitle(t, mode),
+    chart: () => t('ir.raman.chart'),
+    tools: t('ir.raman.tools'),
+    viewer: t('ir.raman.viewer'),
+    viewerHelp: t('ir.raman.viewerHelp'),
+    mark: t('ir.raman.mark'),
+    documentation: t('ir.raman.documentation'),
+    command: (id) => translated(t, commands[id], RAMAN_COMMAND_KEYS[id]),
+  };
+}
+
+/**
+ * What the value axis is called, translated where the catalog has the axis.
+ * @param t - The chrome's formatter.
+ * @param mode - Which value axis.
+ * @returns The title.
+ */
+function modeTitle(t: Translate<ChromeKey>, mode: IrMode): string {
+  const key = MODE_KEYS[mode];
+  return key === undefined ? yAxisTitle(mode) : t(key);
+}
+
+/**
+ * The infrared chart's accessible name. The gestures differ by mode, so the
+ * sentence does too — a label promising the wheel to a reader who cannot watch
+ * it fail to do anything is worse than no label at all.
+ * @param opening - The technique's name, as a sentence opens on it.
+ * @param mode - Which value axis is being drawn.
+ * @returns The label.
+ */
+function infraredChartLabel(opening: string, mode: IrMode): string {
+  const axis = `${opening} spectrum read as ${yAxisTitle(mode)}, wavenumber running from high at the left to low at the right.`;
+  return boxZoomOnly(mode)
+    ? `${axis} Drag a rectangle over it to zoom to that rectangle, and double click to fit everything again.`
+    : `${axis} Drag across it to zoom the wavenumber axis, drag past the baseline to take the value axis with it, turn the wheel to scale the value axis, and double click to fit everything again.`;
+}
+
+/**
+ * A command with its words read from the catalog where it has them.
+ * @param t - The chrome's formatter.
+ * @param entry - The command as its table words it.
+ * @param keys - The catalog keys of its title and description, if any.
+ * @returns The command, translated.
+ */
+function translated(
+  t: Translate<ChromeKey>,
+  entry: IrCommand | undefined,
+  keys: CommandKeys | undefined,
+): IrCommand | undefined {
+  if (entry === undefined || keys === undefined) return entry;
+  return {
+    ...entry,
+    ...(keys.title === undefined ? {} : { title: t(keys.title) }),
+    ...(keys.description === undefined
+      ? {}
+      : { description: t(keys.description) }),
+  };
+}
+
+/** Where a command's words are kept in the catalog. */
+interface CommandKeys {
+  /**
+   * Its title's key.
+   * @default the table's title
+   */
+  title?: ChromeKey;
+  /**
+   * Its description's key.
+   * @default the table's description
+   */
+  description?: ChromeKey;
+}
+
+/** The value axes the catalog has a name for. */
+const MODE_KEYS: Partial<Record<IrMode, ChromeKey>> = {
+  intensity: 'ir.mode.intensity',
+};
+
+/** The catalog keys of every command a Raman viewer words its own way. */
+const RAMAN_COMMAND_KEYS: Partial<Record<IrCommandId, CommandKeys>> = {
+  about: { title: 'ir.raman.about' },
+  documentation: { description: 'ir.raman.command.documentation' },
+  readTool: { description: 'ir.raman.command.readTool' },
+  boxTool: { description: 'ir.raman.command.boxTool' },
+  zoomIn: { description: 'ir.raman.command.zoomIn' },
+  togglePicking: { description: 'ir.raman.command.togglePicking' },
+};

package/src/ir/ui/useIrZoom.ts

@@ -21,10 +21,18 @@ import { useChartZoom } from '../../chart/ui/useChartZoom.ts';
 import { fittedTo, fullDomain } from '../core/irDomain.ts';
 import { yAxisRules, zoomGestures } from '../core/irMode.ts';
 import type { IrDomain, IrMode, IrSpectrum } from '../core/irSpectrum.ts';
+import type { IrTechnique } from '../core/irTechnique.ts';
+import { IR_TECHNIQUE_RULES } from '../core/irTechnique.ts';
 
 export interface IrZoomOptions {
   /** Everything the chart holds, which is what the window is fitted to. */
   spectra: readonly IrSpectrum[];
+  /**
+   * What the spectra were measured with, which decides which way the
+   * wavenumber axis runs.
+   * @default 'infrared'
+   */
+  technique?: IrTechnique;
   /** Which value axis is being drawn. */
   mode: IrMode;
   /** The SVG the gestures are made on, as it was handed to its `ref`. */
@@ -58,6 +66,7 @@ export interface IrZoomOptions {
 export function useIrZoom(options: IrZoomOptions): ChartZoom {
   const {
     spectra,
+    technique = 'infrared',
     mode,
     svgRef,
     plot,
@@ -71,8 +80,8 @@ export function useIrZoom(options: IrZoomOptions): ChartZoom {
   const gestures = useMemo(() => zoomGestures(mode, drag), [mode, drag]);
 
   // `reverseX` is not decoration: the hook measures every gesture by inverting a
-  // pixel through the scale it builds, so it has to build the same reversed one
-  // the chart draws with.
+  // pixel through the scale it builds, so it has to build the same scale the
+  // chart draws with — reversed for infrared, forward for Raman.
   return useChartZoom({
     fitted,
     fitKey,
@@ -81,6 +90,6 @@ export function useIrZoom(options: IrZoomOptions): ChartZoom {
     yAxis,
     domain,
     gestures,
-    reverseX: true,
+    reverseX: IR_TECHNIQUE_RULES[technique].reverseX,
   });
 }

package/src/ir/ui/useValueAxisZoom.ts

@@ -0,0 +1,67 @@
+/**
+ * The zoom in and zoom out commands, which scale the value axis alone.
+ *
+ * They scale it about the baseline the mode hangs from — 100 for percent
+ * transmittance, zero for absorbance and intensity — so a weak band comes up
+ * out of its baseline rather than the whole trace drifting off the plot.
+ */
+
+import { useMemo } from 'react';
+
+import { fullDomain } from '../core/irDomain.ts';
+import { yAxisRules } from '../core/irMode.ts';
+
+import { useIrActions, useIrEditorState } from './irStateContext.ts';
+
+/** The two commands, ready to hand to a button or a key. */
+export interface ValueAxisZoom {
+  /** Bring the bands up by one step. */
+  zoomIn: () => void;
+  /** Put the axis back out by one step. */
+  zoomOut: () => void;
+}
+
+/**
+ * Zoom the value axis of the viewer this is called inside.
+ * @returns The two commands.
+ */
+export function useValueAxisZoom(): ValueAxisZoom {
+  const { state, visibleSpectra } = useIrEditorState();
+  const actions = useIrActions();
+  const { domain } = state.view;
+  const { mode } = state.settings;
+
+  return useMemo(() => {
+    /**
+     * Scale the value axis by a factor, about the baseline the mode hangs from.
+     * @param factor - Above one to zoom out.
+     */
+    function scale(factor: number): void {
+      const shown = domain ?? fullDomain(visibleSpectra, mode);
+      // Asked of the mode rather than written out again here: the baseline a
+      // value axis is scaled about is `irMode`'s to know, and a second copy of
+      // it is a second thing to get wrong.
+      const { baseline = 0 } = yAxisRules(mode);
+      actions.setDomain({
+        x: shown.x,
+        y: [
+          baseline + (shown.y[0] - baseline) * factor,
+          baseline + (shown.y[1] - baseline) * factor,
+        ],
+      });
+    }
+    return {
+      zoomIn: () => scale(1 / ZOOM_STEP),
+      zoomOut: () => scale(ZOOM_STEP),
+    };
+  }, [actions, domain, visibleSpectra, mode]);
+}
+
+/**
+ * What one press of zoom in or out is worth.
+ *
+ * A fifth, which is about what one notch of a mouse wheel does — so the button
+ * and the wheel feel like the same gesture at two speeds rather than two
+ * different ones.
+ */
+const ZOOM_STEP = 1.2;

package/src/ir.ts

@@ -7,6 +7,9 @@
  * arrive in — `ir-spectrum` for the band correlations, `convert-to-jcamp` for
  * writing them back out, and a JCAMP or SPC reader fetched only once the bytes
  * turn out to need it. A site with no spectra to look at installs none of it.
+ *
+ * Raman spectra are drawn by the same code, opened through
+ * `react-cheminfo/raman`.
  */
 
 export * from './ir/core/index.ts';

package/src/locales/de.json

@@ -663,5 +663,24 @@
   "moleculesToken.fix.issueOnServer": "Oder auf dem Server von molecules.cheminfo.org:",
   "moleculesToken.fix.envOne": "Tragen Sie es in die .env des Servers dieser Website ein:",
   "moleculesToken.fix.envMany": "Tragen Sie sie in die .env des Servers dieser Website ein:",
-  "moleculesToken.fix.restart": "Starten Sie die Dienste neu, da sie die .env nur beim Start lesen:"
+  "moleculesToken.fix.restart": "Starten Sie die Dienste neu, da sie die .env nur beim Start lesen:",
+  "ir.mode.intensity": "Intensität",
+  "ir.raman.xTitle": "Raman-Verschiebung (cm⁻¹)",
+  "ir.raman.chart": "Raman-Spektrum, als Intensität gelesen, die Raman-Verschiebung von links nach rechts steigend. Ziehen Sie darüber, um die Achse der Raman-Verschiebung zu zoomen, ziehen Sie über die Grundlinie hinaus, um die Intensitätsachse mitzunehmen, drehen Sie das Mausrad, um die Intensitätsachse zu skalieren, und doppelklicken Sie, um wieder alles einzupassen.",
+  "ir.raman.tools": "Werkzeuge für das Raman-Spektrum",
+  "ir.raman.viewer": "Raman-Spektrenbetrachter",
+  "ir.raman.viewerHelp": "Hilfe zum Raman-Spektrenbetrachter",
+  "ir.raman.mark": "Raman-Betrachter",
+  "ir.raman.about": "Über den Raman-Betrachter",
+  "ir.raman.documentation": "Den Raman-Betrachter verwenden",
+  "ir.raman.command.documentation": "Wie die Banden gelesen werden, und jede Geste.",
+  "ir.raman.command.readTool": "Ein Ziehen verengt die Achse der Raman-Verschiebung. Über die Grundlinie hinaus losgelassen, nimmt es die Intensitätsachse mit.",
+  "ir.raman.command.boxTool": "Ein Ziehen zoomt genau auf das Rechteck, das es aufspannt, beide Achsen zugleich — um in eine Grundlinie oder eine Schulter hineinzusehen statt über das ganze Spektrum.",
+  "ir.raman.command.zoomIn": "Hebt die schwachen Banden hervor, indem die Intensitätsachse um null skaliert wird.",
+  "ir.raman.command.togglePicking": "Findet die Banden des ausgewählten Spektrums, markiert sie im Diagramm und listet sie auf.",
+  "ir.raman.doc.bands": "Die Banden des *ausgewählten* Spektrums werden als Intensitätsmaxima gefunden, im Diagramm markiert und im Bandenbereich aufgelistet. Fahren Sie über eine Zeile, wird die Bande im Diagramm markiert; fahren Sie über das Diagramm, leuchtet die Zeile auf.",
+  "ir.raman.doc.sampled": "Eine Bande wird an dem abgetasteten Punkt angegeben, an dem sie ihr Maximum hat: Ihre Lage ist nur so genau wie das Raster, auf dem das Spektrum aufgenommen wurde.",
+  "ir.raman.aboutLead": "Zeichnet ein Raman-Spektrum, findet seine Banden und listet sie neben dem Diagramm auf.",
+  "ir.raman.credit.picking": "**ir-spectrum** (cheminfo, MIT) findet die Banden, mit dem Peakfinder von **common-spectrum** und **ml-gsd**.",
+  "ir.raman.credit.jcamp": "**convert-to-jcamp** (cheminfo, MIT) schreibt die heruntergeladene JCAMP-DX-Datei."
 }

package/src/locales/en.json

@@ -663,5 +663,24 @@
   "moleculesToken.fix.issueOnServer": "Or, on the server of molecules.cheminfo.org:",
   "moleculesToken.fix.envOne": "Write it in the .env of this site's server:",
   "moleculesToken.fix.envMany": "Write them in the .env of this site's server:",
-  "moleculesToken.fix.restart": "Restart the services, which read the .env only when they start:"
+  "moleculesToken.fix.restart": "Restart the services, which read the .env only when they start:",
+  "ir.mode.intensity": "intensity",
+  "ir.raman.xTitle": "Raman shift (cm⁻¹)",
+  "ir.raman.chart": "Raman spectrum read as intensity, Raman shift running from low at the left to high at the right. Drag across it to zoom the Raman shift axis, drag past the baseline to take the intensity axis with it, turn the wheel to scale the intensity axis, and double click to fit everything again.",
+  "ir.raman.tools": "Raman spectrum tools",
+  "ir.raman.viewer": "Raman spectrum viewer",
+  "ir.raman.viewerHelp": "Raman spectrum viewer help",
+  "ir.raman.mark": "Raman viewer",
+  "ir.raman.about": "About the Raman viewer",
+  "ir.raman.documentation": "Using the Raman viewer",
+  "ir.raman.command.documentation": "How the bands are read, and every gesture.",
+  "ir.raman.command.readTool": "A drag narrows the Raman shift axis. Released past the baseline, it takes the intensity axis with it.",
+  "ir.raman.command.boxTool": "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.",
+  "ir.raman.command.zoomIn": "Brings the weak bands up, scaling the intensity axis about zero.",
+  "ir.raman.command.togglePicking": "Finds the bands of the selected spectrum, marks them on the chart and lists them.",
+  "ir.raman.doc.bands": "The bands of the *selected* spectrum are picked as maxima of intensity, marked on the chart and listed in the bands panel. Hovering a row marks the band on the chart, and hovering the chart lights the row.",
+  "ir.raman.doc.sampled": "A band is reported at the sampled point it peaked on, so its position is only as precise as the grid the spectrum was recorded on.",
+  "ir.raman.aboutLead": "Draws a Raman spectrum, picks its bands and lists them beside the chart.",
+  "ir.raman.credit.picking": "**ir-spectrum** (cheminfo, MIT) picks the bands, with the peak picker of **common-spectrum** and **ml-gsd**.",
+  "ir.raman.credit.jcamp": "**convert-to-jcamp** (cheminfo, MIT) writes the JCAMP-DX download."
 }

package/src/locales/es.json

@@ -663,5 +663,24 @@
   "moleculesToken.fix.issueOnServer": "O, en el servidor de molecules.cheminfo.org:",
   "moleculesToken.fix.envOne": "Escríbalo en el .env del servidor de este sitio:",
   "moleculesToken.fix.envMany": "Escríbalos en el .env del servidor de este sitio:",
-  "moleculesToken.fix.restart": "Reinicie los servicios, que solo leen el .env al arrancar:"
+  "moleculesToken.fix.restart": "Reinicie los servicios, que solo leen el .env al arrancar:",
+  "ir.mode.intensity": "intensidad",
+  "ir.raman.xTitle": "desplazamiento Raman (cm⁻¹)",
+  "ir.raman.chart": "Espectro Raman leído como intensidad, con el desplazamiento Raman creciendo de izquierda a derecha. Arrastre sobre él para ampliar el eje del desplazamiento Raman, arrastre más allá de la línea de base para llevarse también el eje de intensidad, gire la rueda para escalar el eje de intensidad y haga doble clic para volver a ajustarlo todo.",
+  "ir.raman.tools": "Herramientas del espectro Raman",
+  "ir.raman.viewer": "Visor de espectros Raman",
+  "ir.raman.viewerHelp": "Ayuda del visor de espectros Raman",
+  "ir.raman.mark": "Visor Raman",
+  "ir.raman.about": "Acerca del visor Raman",
+  "ir.raman.documentation": "Uso del visor Raman",
+  "ir.raman.command.documentation": "Cómo se leen las bandas, y cada gesto.",
+  "ir.raman.command.readTool": "Un arrastre estrecha el eje del desplazamiento Raman. Soltado más allá de la línea de base, se lleva también el eje de intensidad.",
+  "ir.raman.command.boxTool": "Un arrastre amplía exactamente el rectángulo que traza, los dos ejes a la vez — para mirar dentro de una línea de base o de un hombro en lugar de a lo largo del espectro.",
+  "ir.raman.command.zoomIn": "Hace destacar las bandas débiles, escalando el eje de intensidad en torno a cero.",
+  "ir.raman.command.togglePicking": "Encuentra las bandas del espectro seleccionado, las marca en la gráfica y las enumera.",
+  "ir.raman.doc.bands": "Las bandas del espectro *seleccionado* se buscan como máximos de intensidad, se marcan en la gráfica y se enumeran en el panel de bandas. Pasar sobre una fila marca la banda en la gráfica, y pasar sobre la gráfica ilumina la fila.",
+  "ir.raman.doc.sampled": "Una banda se da en el punto muestreado donde alcanza su máximo: su posición no es más precisa que la rejilla en la que se registró el espectro.",
+  "ir.raman.aboutLead": "Dibuja un espectro Raman, encuentra sus bandas y las enumera junto a la gráfica.",
+  "ir.raman.credit.picking": "**ir-spectrum** (cheminfo, MIT) encuentra las bandas, con el detector de picos de **common-spectrum** y **ml-gsd**.",
+  "ir.raman.credit.jcamp": "**convert-to-jcamp** (cheminfo, MIT) escribe el archivo JCAMP-DX descargado."
 }

package/src/locales/fr.json

@@ -663,5 +663,24 @@
   "moleculesToken.fix.issueOnServer": "Ou, sur le serveur de molecules.cheminfo.org :",
   "moleculesToken.fix.envOne": "Écrivez-le dans le fichier .env du serveur de ce site :",
   "moleculesToken.fix.envMany": "Écrivez-les dans le fichier .env du serveur de ce site :",
-  "moleculesToken.fix.restart": "Redémarrez les services, qui ne lisent le fichier .env qu'à leur démarrage :"
+  "moleculesToken.fix.restart": "Redémarrez les services, qui ne lisent le fichier .env qu'à leur démarrage :",
+  "ir.mode.intensity": "intensité",
+  "ir.raman.xTitle": "déplacement Raman (cm⁻¹)",
+  "ir.raman.chart": "Spectre Raman lu en intensité, le déplacement Raman croissant de gauche à droite. Glissez dessus pour zoomer sur l'axe du déplacement Raman, glissez au-delà de la ligne de base pour entraîner aussi l'axe des intensités, tournez la molette pour mettre l'axe des intensités à l'échelle, et double-cliquez pour tout réajuster.",
+  "ir.raman.tools": "Outils du spectre Raman",
+  "ir.raman.viewer": "Visionneuse de spectres Raman",
+  "ir.raman.viewerHelp": "Aide de la visionneuse de spectres Raman",
+  "ir.raman.mark": "Visionneuse Raman",
+  "ir.raman.about": "À propos de la visionneuse Raman",
+  "ir.raman.documentation": "Utiliser la visionneuse Raman",
+  "ir.raman.command.documentation": "Comment les bandes sont lues, et chaque geste.",
+  "ir.raman.command.readTool": "Un glissement resserre l'axe du déplacement Raman. Relâché au-delà de la ligne de base, il entraîne aussi l'axe des intensités.",
+  "ir.raman.command.boxTool": "Un glissement zoome exactement sur le rectangle qu'il trace, les deux axes à la fois — pour regarder dans une ligne de base ou un épaulement plutôt qu'à travers le spectre.",
+  "ir.raman.command.zoomIn": "Fait ressortir les bandes faibles, en mettant l'axe des intensités à l'échelle autour de zéro.",
+  "ir.raman.command.togglePicking": "Trouve les bandes du spectre sélectionné, les marque sur le graphique et les liste.",
+  "ir.raman.doc.bands": "Les bandes du spectre *sélectionné* sont repérées comme maxima d'intensité, marquées sur le graphique et listées dans le panneau des bandes. Survoler une ligne marque la bande sur le graphique, et survoler le graphique éclaire la ligne.",
+  "ir.raman.doc.sampled": "Une bande est donnée au point échantillonné où elle culmine : sa position n'est pas plus précise que la grille sur laquelle le spectre a été enregistré.",
+  "ir.raman.aboutLead": "Trace un spectre Raman, repère ses bandes et les liste à côté du graphique.",
+  "ir.raman.credit.picking": "**ir-spectrum** (cheminfo, MIT) repère les bandes, avec le détecteur de pics de **common-spectrum** et **ml-gsd**.",
+  "ir.raman.credit.jcamp": "**convert-to-jcamp** (cheminfo, MIT) écrit le fichier JCAMP-DX téléchargé."
 }