react-cheminfo 0.65.0 → 0.67.0

package/src/ir/core/spectrumJcamp.ts

@@ -7,7 +7,8 @@
  * turned inside out, and a bare column of numbers leaves whoever opens it next
  * to guess which. `##YUNITS=` states it, and `ir-spectrum` reads it back and
  * derives the other axis from it, so a spectrum written here returns carrying
- * both.
+ * both. A Raman spectrum is written as its intensity, under a `##DATA TYPE=`
+ * that says it is Raman.
  *
  * The points are written as an `##PEAK TABLE=` of explicit `x y` pairs rather
  * than as a compressed `##XYDATA=` record. An XYDATA record states a first
@@ -20,6 +21,7 @@
 import { fromJSON } from 'convert-to-jcamp';
 
 import type { IrMode, IrSpectrum } from './irSpectrum.ts';
+import { IR_TECHNIQUE_RULES, irModeTechnique } from './irTechnique.ts';
 
 /** The extension a written spectrum is saved under. */
 export const JCAMP_EXTENSION = '.jdx';
@@ -27,8 +29,8 @@ export const JCAMP_EXTENSION = '.jdx';
 /** What a JCAMP-DX file is served as. */
 export const JCAMP_MIME_TYPE = 'chemical/x-jcamp-dx';
 
-/** How the technique is named when the file that was read named nothing. */
-export const DEFAULT_DATA_TYPE = 'INFRARED SPECTRUM';
+/** The infrared data type, written when the file that was read named none. */
+export const DEFAULT_DATA_TYPE = IR_TECHNIQUE_RULES.infrared.dataType;
 
 /**
  * Write one spectrum as a JCAMP-DX block.
@@ -37,15 +39,20 @@ export const DEFAULT_DATA_TYPE = 'INFRARED SPECTRUM';
  * which that was, and only otherwise the one being read. Writing what is on
  * screen instead would export a spectrum that had been through a logarithm it
  * was never measured with — and, where a band bottoms out at zero transmittance,
- * an absorbance of infinity that no reader can take back.
+ * an absorbance of infinity that no reader can take back. A spectrum carrying
+ * neither falls back on whichever axis it does carry, so a Raman spectrum is
+ * written as its intensity.
  * @param spectrum - The spectrum.
  * @param mode - The axis being read, used when the file named none.
  * @returns The block, `##TITLE=` through `##END=`.
+ * @throws {Error} When the spectrum carries no value axis at all.
  */
 export function irSpectrumToJcamp(spectrum: IrSpectrum, mode: IrMode): string {
-  const written = spectrum.origin.recorded ?? mode;
-  const values =
-    written === 'absorbance' ? spectrum.absorbance : spectrum.transmittance;
+  const written = writtenAxis(spectrum, mode);
+  const values = spectrum[written];
+  if (values === undefined) {
+    throw new Error(`${spectrum.name} carries no value axis to write.`);
+  }
   return fromJSON(
     { x: spectrum.wavenumber, y: values },
     { info: infoRecords(spectrum, written), meta: metaRecords(spectrum) },
@@ -67,13 +74,14 @@ export function irSpectrumToJcamp(spectrum: IrSpectrum, mode: IrMode): string {
  * spectrum would have written.
  * @param spectra - The spectra, in the order the list holds them.
  * @param mode - The axis being read, used for a spectrum whose file named none.
- * @param title - What to call the file's own outer block.
+ * @param title - What to call the file's own outer block. Defaults to the
+ * count and the technique that reads `mode`: `2 infrared spectra`.
  * @returns The file.
  */
 export function irSpectraToJcamp(
   spectra: readonly IrSpectrum[],
   mode: IrMode,
-  title = `${spectra.length} infrared spectra`,
+  title = `${spectra.length} ${IR_TECHNIQUE_RULES[irModeTechnique(mode)].name} spectra`,
 ): string {
   const only = spectra.length === 1 ? spectra[0] : undefined;
   if (only !== undefined) return irSpectrumToJcamp(only, mode);
@@ -91,6 +99,32 @@ ${blocks.join('\n')}
 `;
 }
 
+/**
+ * Which axis of a spectrum is written.
+ * @param spectrum - The spectrum.
+ * @param mode - The axis being read.
+ * @returns The axis its file recorded, else the one being read, else the first
+ * it carries; `mode` when it carries none, which the caller refuses.
+ */
+function writtenAxis(spectrum: IrSpectrum, mode: IrMode): IrMode {
+  const { recorded } = spectrum.origin;
+  if (recorded !== undefined && spectrum[recorded] !== undefined) {
+    return recorded;
+  }
+  if (spectrum[mode] !== undefined) return mode;
+  for (const axis of WRITTEN_AXES) {
+    if (spectrum[axis] !== undefined) return axis;
+  }
+  return mode;
+}
+
+/** The axes a spectrum may carry, in the order one is looked for. */
+const WRITTEN_AXES: readonly IrMode[] = [
+  'transmittance',
+  'absorbance',
+  'intensity',
+];
+
 /**
  * The standard records of a block: what it is called, and what its axes are.
  * @param spectrum - The spectrum.
@@ -103,17 +137,32 @@ function infoRecords(
 ): Record<string, string> {
   return {
     title: recordValue(spectrum.name),
-    // The technique as the file stated it, so a Raman spectrum that was opened
-    // here is not written back out claiming to be infrared.
-    dataType: technique(spectrum) ?? DEFAULT_DATA_TYPE,
+    // The technique as the file stated it, and otherwise the one the written
+    // axis belongs to, so a Raman spectrum is never written out claiming to be
+    // infrared.
+    dataType:
+      technique(spectrum) ??
+      IR_TECHNIQUE_RULES[irModeTechnique(written)].dataType,
     xUnits: '1/CM',
-    // Spelled the way `ir-spectrum` reads it: it takes the axis to be
-    // transmittance when the label says `trans`, and to be a percentage rather
-    // than a fraction when it carries a `%`.
-    yUnits: written === 'absorbance' ? 'ABSORBANCE' : 'Transmittance (%)',
+    yUnits: Y_UNITS[written],
   };
 }
 
+/**
+ * What each axis is called in `##YUNITS=`.
+ *
+ * Spelled the way `ir-spectrum` reads them: it takes the axis to be
+ * transmittance when the label says `trans`, and to be a percentage rather than
+ * a fraction when it carries a `%`. A Raman intensity has no unit of its own —
+ * counts on one instrument, a fraction of the strongest band on another — so it
+ * is named, as Raman instruments write it.
+ */
+const Y_UNITS: Record<IrMode, string> = {
+  transmittance: 'Transmittance (%)',
+  absorbance: 'ABSORBANCE',
+  intensity: 'INTENSITY',
+};
+
 /**
  * The `$`-prefixed records of a block: the acquisition, as the file stated it.
  *

package/src/ir/core/toIrSpectrum.ts

@@ -64,8 +64,7 @@ export function toIrSpectrum(
     name: name ?? loaded.name ?? loaded.origin.fileName ?? 'spectrum',
     color,
     wavenumber: loaded.wavenumber,
-    absorbance: loaded.absorbance,
-    transmittance: loaded.transmittance,
+    ...valueAxes(loaded),
     meta: loaded.meta,
     origin: loaded.origin,
     visible,
@@ -100,3 +99,22 @@ export function toIrSpectra(
   }
   return spectra;
 }
+
+/**
+ * The value axes a loaded spectrum carries, and only those.
+ *
+ * An absent axis is an absent key, never a key holding `undefined`: the two
+ * read the same in a debugger and differently in every structural comparison.
+ * @param loaded - What the reader produced.
+ * @returns Its absorbance and transmittance, or its intensity.
+ */
+function valueAxes(
+  loaded: LoadedIrSpectrum,
+): Pick<IrSpectrum, 'absorbance' | 'transmittance' | 'intensity'> {
+  const { absorbance, transmittance, intensity } = loaded;
+  return {
+    ...(absorbance === undefined ? {} : { absorbance }),
+    ...(transmittance === undefined ? {} : { transmittance }),
+    ...(intensity === undefined ? {} : { intensity }),
+  };
+}

package/src/ir/ui/BandRow.tsx

@@ -0,0 +1,107 @@
+import { Icon } from '@blueprintjs/core';
+
+import {
+  panelCellStyle,
+  panelNumberCellStyle,
+} from '../../panel/core/panelStyles.ts';
+import type { AssignedBand } from '../core/assignBands.ts';
+import type { IrBand } from '../core/irBand.ts';
+import { bandValue } from '../core/irBand.ts';
+import { formatIrValue, formatWavenumber } from '../core/irFormat.ts';
+import type { IrMode } from '../core/irSpectrum.ts';
+
+export interface BandRowProps {
+  /** The band and everything it might be. */
+  entry: AssignedBand;
+  /** Which value axis is being read. */
+  mode: IrMode;
+  /** Whether the row has a column for what the band could be. */
+  assignments: boolean;
+  /** Whether the pointer is on this band, here or on the chart. */
+  lit: boolean;
+  /**
+   * Told when the pointer arrives on this row, and when it leaves.
+   * @default undefined
+   */
+  onHighlight?: (band: IrBand | null) => void;
+}
+
+/**
+ * One band: where it is, how strong, and every vibration it could be.
+ *
+ * The candidates are written as one line rather than a list, so a strong band
+ * with four of them stays one row of the table and the wavenumbers keep reading
+ * down the column. The `title` carries them again with each one's note, which is
+ * where the reason to prefer one lives.
+ * @param props - Component props.
+ * @returns The row.
+ */
+export function BandRow(props: BandRowProps) {
+  const { entry, mode, assignments, lit, onHighlight } = props;
+  const { band } = entry;
+
+  return (
+    <tr
+      style={lit ? litRowStyle : undefined}
+      onPointerEnter={() => onHighlight?.(band)}
+      onPointerLeave={() => onHighlight?.(null)}
+    >
+      <td style={panelNumberCellStyle}>{formatWavenumber(band.wavenumber)}</td>
+      <td style={panelCellStyle} title={STRENGTH_TITLES[band.strength]}>
+        {band.strength}
+      </td>
+      <td style={panelNumberCellStyle}>
+        {formatIrValue(bandValue(band, mode) ?? Number.NaN, mode)}
+      </td>
+      {assignments ? <CandidatesCell entry={entry} /> : null}
+    </tr>
+  );
+}
+
+interface CandidatesCellProps {
+  /** The band and everything it might be. */
+  entry: AssignedBand;
+}
+
+/**
+ * What a band could be: the narrowest candidate, and how many more there are.
+ * @param props - Component props.
+ * @returns The cell.
+ */
+function CandidatesCell(props: CandidatesCellProps) {
+  const { candidates } = props.entry;
+  const detail = candidates
+    .map((candidate) =>
+      candidate.note === undefined
+        ? `${candidate.group} ${candidate.vibration}`
+        : `${candidate.group} ${candidate.vibration} — ${candidate.note}`,
+    )
+    .join('\n');
+
+  return (
+    <td style={panelCellStyle} title={detail}>
+      {candidates.length === 0 ? (
+        <span style={{ opacity: 0.5 }}>—</span>
+      ) : (
+        <span style={{ whiteSpace: 'normal' }}>
+          {candidates[0]?.group} {candidates[0]?.vibration}
+          {candidates.length > 1 ? (
+            <span style={{ opacity: 0.6 }}>
+              {' '}
+              <Icon icon="more" size={10} /> {candidates.length - 1} more
+            </span>
+          ) : null}
+        </span>
+      )}
+    </td>
+  );
+}
+
+/** What each strength letter means, for the column that shows only the letter. */
+const STRENGTH_TITLES = {
+  w: 'weak, relative to this spectrum',
+  m: 'medium, relative to this spectrum',
+  S: 'strong, relative to this spectrum',
+} as const;
+
+const litRowStyle = { background: '#fff3e0' } as const;

package/src/ir/ui/BandsPanel.tsx

@@ -1,22 +1,21 @@
-import { Icon } from '@blueprintjs/core';
 import { useMemo } from 'react';
 import { Button, Toolbar } from 'react-science/ui';
 
 import {
   panelBodyStyle,
-  panelCellStyle,
   panelEmptyStyle,
   panelHeaderCellStyle,
-  panelNumberCellStyle,
   panelStyle,
   panelTableStyle,
   panelToolbarStyle,
 } from '../../panel/core/panelStyles.ts';
-import type { AssignedBand } from '../core/assignBands.ts';
 import type { IrBand } from '../core/irBand.ts';
 import { sameIrBand } from '../core/irBand.ts';
-import { formatIrValue, formatWavenumber } from '../core/irFormat.ts';
+import { shortModeLabel } from '../core/irFormat.ts';
+import { IR_TECHNIQUE_RULES } from '../core/irTechnique.ts';
 
+import { BandRow } from './BandRow.tsx';
+import { bandsToTsv } from './bandsTsv.ts';
 import { useIrActions, useIrEditorState } from './irStateContext.ts';
 
 export interface BandsPanelProps {
@@ -45,6 +44,10 @@ export interface BandsPanelProps {
  * Hovering a row marks the band on the chart and hovering the chart lights the
  * row, which is the whole reason the highlight is threaded through the shell
  * rather than held here: the two views are of one thing.
+ *
+ * For a technique the correlation table does not cover — Raman — the column of
+ * candidates and the button naming them are left out, and the table is the
+ * bands themselves.
  * @param props - Component props.
  * @returns The panel.
  */
@@ -52,11 +55,16 @@ export function BandsPanel(props: BandsPanelProps) {
   const { highlight = null, onHighlight } = props;
   const { state, selectedSpectrum, assigned } = useIrEditorState();
   const actions = useIrActions();
-  const { mode, pickBands, showAssignments, picking } = state.settings;
+  const { mode, pickBands, showAssignments, picking, technique } =
+    state.settings;
+  const { assignments } = IR_TECHNIQUE_RULES[technique];
 
   const rows = useMemo(() => assigned, [assigned]);
 
-  const tsv = useMemo(() => bandsToTsv(rows, mode), [rows, mode]);
+  const tsv = useMemo(
+    () => bandsToTsv(rows, mode, assignments),
+    [rows, mode, assignments],
+  );
 
   return (
     <div style={panelStyle}>
@@ -69,16 +77,18 @@ export function BandsPanel(props: BandsPanelProps) {
             aria-label="Pick the bands"
             onClick={() => actions.setSettings({ pickBands: !pickBands })}
           />
-          <Toolbar.Item
-            icon="label"
-            active={showAssignments}
-            tooltip="Name the assignments on the chart"
-            aria-label="Name the assignments on the chart"
-            disabled={!pickBands}
-            onClick={() =>
-              actions.setSettings({ showAssignments: !showAssignments })
-            }
-          />
+          {assignments ? (
+            <Toolbar.Item
+              icon="label"
+              active={showAssignments}
+              tooltip="Name the assignments on the chart"
+              aria-label="Name the assignments on the chart"
+              disabled={!pickBands}
+              onClick={() =>
+                actions.setSettings({ showAssignments: !showAssignments })
+              }
+            />
+          ) : null}
         </Toolbar>
 
         {/* The threshold is the one picking setting worth reaching for while
@@ -134,9 +144,11 @@ export function BandsPanel(props: BandsPanelProps) {
                 <th style={panelHeaderCellStyle}>cm⁻¹</th>
                 <th style={panelHeaderCellStyle} />
                 <th style={{ ...panelHeaderCellStyle, textAlign: 'right' }}>
-                  {mode === 'absorbance' ? 'A' : '%T'}
+                  {shortModeLabel(mode)}
                 </th>
-                <th style={panelHeaderCellStyle}>could be</th>
+                {assignments ? (
+                  <th style={panelHeaderCellStyle}>could be</th>
+                ) : null}
               </tr>
             </thead>
             <tbody>
@@ -145,6 +157,7 @@ export function BandsPanel(props: BandsPanelProps) {
                   key={`${entry.band.spectrumId} ${entry.band.wavenumber}`}
                   entry={entry}
                   mode={mode}
+                  assignments={assignments}
                   lit={sameIrBand(entry.band, highlight)}
                   onHighlight={onHighlight}
                 />
@@ -157,112 +170,6 @@ export function BandsPanel(props: BandsPanelProps) {
   );
 }
 
-interface BandRowProps {
-  /** The band and everything it might be. */
-  entry: AssignedBand;
-  /** Which value axis is being read. */
-  mode: 'absorbance' | 'transmittance';
-  /** Whether the pointer is on this band, here or on the chart. */
-  lit: boolean;
-  /** Told when the pointer arrives on this row, and when it leaves. */
-  onHighlight?: (band: IrBand | null) => void;
-}
-
-/**
- * One band: where it is, how strong, and every vibration it could be.
- *
- * The candidates are written as one line rather than a list, so a strong band
- * with four of them stays one row of the table and the wavenumbers keep reading
- * down the column. The `title` carries them again with each one's note, which is
- * where the reason to prefer one lives.
- * @param props - Component props.
- * @returns The row.
- */
-function BandRow(props: BandRowProps) {
-  const { entry, mode, lit, onHighlight } = props;
-  const { band, candidates } = entry;
-
-  const value = mode === 'absorbance' ? band.absorbance : band.transmittance;
-  const detail = candidates
-    .map((candidate) =>
-      candidate.note === undefined
-        ? `${candidate.group} ${candidate.vibration}`
-        : `${candidate.group} ${candidate.vibration} — ${candidate.note}`,
-    )
-    .join('\n');
-
-  return (
-    <tr
-      style={lit ? litRowStyle : undefined}
-      onPointerEnter={() => onHighlight?.(band)}
-      onPointerLeave={() => onHighlight?.(null)}
-    >
-      <td style={panelNumberCellStyle}>{formatWavenumber(band.wavenumber)}</td>
-      <td style={panelCellStyle} title={STRENGTH_TITLES[band.strength]}>
-        {band.strength}
-      </td>
-      <td style={panelNumberCellStyle}>{formatIrValue(value, mode)}</td>
-      <td style={panelCellStyle} title={detail}>
-        {candidates.length === 0 ? (
-          <span style={{ opacity: 0.5 }}>—</span>
-        ) : (
-          <span style={{ whiteSpace: 'normal' }}>
-            {candidates[0]?.group} {candidates[0]?.vibration}
-            {candidates.length > 1 ? (
-              <span style={{ opacity: 0.6 }}>
-                {' '}
-                <Icon icon="more" size={10} /> {candidates.length - 1} more
-              </span>
-            ) : null}
-          </span>
-        )}
-      </td>
-    </tr>
-  );
-}
-
-/** What each strength letter means, for the column that shows only the letter. */
-const STRENGTH_TITLES = {
-  w: 'weak, relative to this spectrum',
-  m: 'medium, relative to this spectrum',
-  S: 'strong, relative to this spectrum',
-} as const;
-
-/**
- * The table as text, for pasting into a notebook.
- *
- * Tab separated with every candidate on the 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.
- * @param rows - The bands, as they are shown.
- * @param mode - Which value axis is being read.
- * @returns The table, one line per band, with a heading.
- */
-function bandsToTsv(
-  rows: readonly AssignedBand[],
-  mode: 'absorbance' | 'transmittance',
-): string {
-  const heading = ['wavenumber', 'strength', mode, 'could be'].join('\t');
-  const lines = rows.map((entry) =>
-    [
-      formatWavenumber(entry.band.wavenumber),
-      entry.band.strength,
-      formatIrValue(
-        mode === 'absorbance'
-          ? entry.band.absorbance
-          : entry.band.transmittance,
-        mode,
-      ),
-      entry.candidates
-        .map((candidate) => `${candidate.group} ${candidate.vibration}`)
-        .join('; '),
-    ].join('\t'),
-  );
-  return [heading, ...lines].join('\n');
-}
-
-const litRowStyle = { background: '#fff3e0' } as const;
-
 const thresholdStyle = {
   display: 'inline-flex',
   alignItems: 'center',

package/src/ir/ui/IrAboutDialog.tsx

@@ -1,12 +1,24 @@
 import { Dialog, DialogBody } from '@blueprintjs/core';
 
+import { Prose } from '../../i18n/ui/Prose.tsx';
+import { useChromeT } from '../../i18n/ui/useT.ts';
+import { irCommands } from '../core/irCommands.ts';
+import type { IrTechnique } from '../core/irTechnique.ts';
+
 import { IrLogo } from './IrLogo.tsx';
+import { useIrText } from './useIrText.ts';
 
 export interface IrAboutDialogProps {
   /** Whether the dialog is open. */
   isOpen: boolean;
   /** Close it. */
   onClose: () => void;
+  /**
+   * What the spectra were measured with, which decides what the viewer says it
+   * does and whom it credits for it.
+   * @default 'infrared'
+   */
+  technique?: IrTechnique;
 }
 
 /**
@@ -20,42 +32,63 @@ export interface IrAboutDialogProps {
  * @returns The dialog.
  */
 export function IrAboutDialog(props: IrAboutDialogProps) {
-  const { isOpen, onClose } = props;
+  const { isOpen, onClose, technique = 'infrared' } = props;
+  const t = useChromeT();
+  const title = (useIrText(technique).command('about') ?? irCommands.about)
+    .title;
+  const raman = technique === 'raman';
 
   return (
     <Dialog
       isOpen={isOpen}
       onClose={onClose}
-      title="About the infrared viewer"
-      icon={<IrLogo size={20} />}
+      title={title}
+      icon={<IrLogo size={20} technique={technique} />}
       style={dialogStyle}
     >
       <DialogBody>
         <div style={brandStyle}>
-          <IrLogo size={64} />
+          <IrLogo size={64} technique={technique} />
           <div>
-            <p style={leadStyle}>react-cheminfo/ir</p>
-            <p style={paragraphStyle}>
-              Draws an infrared spectrum the way infrared is printed, reads it
-              as absorbance or as percent transmittance, picks its bands and
-              offers every functional group each band could be.
-            </p>
+            <p style={leadStyle}>{DOORS[technique]}</p>
+            {raman ? (
+              <p style={paragraphStyle}>{t('ir.raman.aboutLead')}</p>
+            ) : (
+              <p style={paragraphStyle}>
+                Draws an infrared spectrum the way infrared is printed, reads it
+                as absorbance or as percent transmittance, picks its bands and
+                offers every functional group each band could be.
+              </p>
+            )}
           </div>
         </div>
 
         <h4 style={headingStyle}>Credits</h4>
         <ul style={listStyle}>
-          <li>
-            <strong>ir-spectrum</strong> (cheminfo, MIT) reads the JCAMP-DX and
-            SPC files, derives the absorbance/transmittance pair, and picks the
-            bands. This package deliberately does none of that arithmetic
-            itself.
-          </li>
-          <li>
-            <strong>common-spectrum</strong>, <strong>jcampconverter</strong>{' '}
-            and <strong>spc-parser</strong> (cheminfo, MIT) are what it reads
-            through.
-          </li>
+          {raman ? (
+            <>
+              <li>
+                <Prose text={t('ir.raman.credit.picking')} />
+              </li>
+              <li>
+                <Prose text={t('ir.raman.credit.jcamp')} />
+              </li>
+            </>
+          ) : (
+            <>
+              <li>
+                <strong>ir-spectrum</strong> (cheminfo, MIT) reads the JCAMP-DX
+                and SPC files, derives the absorbance/transmittance pair, and
+                picks the bands. This package deliberately does none of that
+                arithmetic itself.
+              </li>
+              <li>
+                <strong>common-spectrum</strong>,{' '}
+                <strong>jcampconverter</strong> and <strong>spc-parser</strong>{' '}
+                (cheminfo, MIT) are what it reads through.
+              </li>
+            </>
+          )}
           <li>
             <strong>ml-spectra-processing</strong> (mljs, MIT) for the array
             work.
@@ -69,13 +102,15 @@ export function IrAboutDialog(props: IrAboutDialogProps) {
             <strong>react-science</strong> and <strong>BlueprintJS</strong>
             (zakodium, Palantir) for the shell this viewer is shaped like.
           </li>
-          <li>
-            The <strong>correlation table</strong> is the conventional teaching
-            set of group frequencies, as any introductory spectroscopy text
-            tabulates them. The ranges are deliberately the rounded, generous
-            ones: narrowing them to look precise would rule out assignments that
-            are genuinely possible.
-          </li>
+          {raman ? null : (
+            <li>
+              The <strong>correlation table</strong> is the conventional
+              teaching set of group frequencies, as any introductory
+              spectroscopy text tabulates them. The ranges are deliberately the
+              rounded, generous ones: narrowing them to look precise would rule
+              out assignments that are genuinely possible.
+            </li>
+          )}
           <li>
             The <strong>colours</strong> are Okabe and Ito&apos;s
             colour-universal palette, so two traces stay distinguishable for a
@@ -87,6 +122,12 @@ export function IrAboutDialog(props: IrAboutDialogProps) {
   );
 }
 
+/** The entry point each technique's viewer is imported from. */
+const DOORS: Record<IrTechnique, string> = {
+  infrared: 'react-cheminfo/ir',
+  raman: 'react-cheminfo/raman',
+};
+
 const dialogStyle = { width: 'min(680px, 92vw)' } as const;
 
 const brandStyle = {