react-cheminfo 0.10.0 → 0.12.0

package/src/spectra/core/settingsProblems.ts

@@ -1,27 +1,29 @@
 import { chainProblems } from './chainProblems.ts';
-import type { SettingsProblem } from './problems.ts';
-import { isNumber, isUsableLabel, isWholeNumber, problem } from './problems.ts';
-import type {
-  MatrixFilterName,
-  ScaleMethod,
-  SpectraSettings,
-} from './settings.ts';
+import {
+  MATRIX_FILTER_NAMES,
+  SCALE_METHODS,
+  isMatrixFilterName,
+  isScaleMethod,
+} from './matrixCatalog.ts';
+import type { ProblemPlace, SettingsProblem } from './problems.ts';
+import {
+  bracketProblem,
+  isNumber,
+  isUsableLabel,
+  isWholeNumber,
+  problem,
+} from './problems.ts';
+import type { SpectraSettings } from './settings.ts';
 import { normalizationFilters } from './settings.ts';
+import { readZones } from './zones.ts';
 
-/** The only three names `getPostProcessedData` matches; anything else throws. */
-export const MATRIX_FILTER_NAMES: readonly MatrixFilterName[] = [
-  'pqn',
-  'centerMean',
-  'rescale',
-];
-
-/** The only four scalings it matches, which it lower-cases before comparing. */
-export const SCALE_METHODS: readonly ScaleMethod[] = [
-  'min',
-  'max',
-  'minmax',
-  'integration',
-];
+const MEMORY: ProblemPlace = { part: 'memory', where: 'Memory' };
+const RESAMPLING: ProblemPlace = { part: 'resampling', where: 'Resampling' };
+const SCALING: ProblemPlace = { part: 'scaling', where: 'Scaling' };
+const CALCULATIONS: ProblemPlace = {
+  part: 'calculation',
+  where: 'Calculations',
+};
 
 /**
  * Everything wrong, or probably wrong, with a whole settings object.
@@ -36,35 +38,36 @@ export const SCALE_METHODS: readonly ScaleMethod[] = [
 export function settingsProblems(settings: SpectraSettings): SettingsProblem[] {
   const problems: SettingsProblem[] = [];
   const normalization = settings.processor.normalization ?? {};
-  const where = 'Resampling';
 
   const { from, to, numberOfPoints, exclusions } = normalization;
   if (isNumber(from) && isNumber(to) && from >= to) {
-    problems.push(problem('error', where, 'From is not below to.'));
+    problems.push(problem('error', RESAMPLING, 'From is not below to.'));
   }
   if (
     numberOfPoints !== undefined &&
     (!isWholeNumber(numberOfPoints) || numberOfPoints < 2)
   ) {
-    problems.push(problem('error', where, 'A grid needs at least two points.'));
+    problems.push(
+      problem('error', RESAMPLING, 'A grid needs at least two points.'),
+    );
   }
   const { maxMemory } = settings.processor;
   if (maxMemory !== undefined && (!isNumber(maxMemory) || maxMemory <= 0)) {
     problems.push(
-      problem('error', 'Memory', 'The budget must be a number above zero.'),
+      problem('error', MEMORY, 'The budget must be a number above zero.'),
     );
   }
 
-  for (const [index, zone] of (exclusions ?? []).entries()) {
-    const zoneWhere = `Excluded zone ${String(index + 1)}`;
+  for (const [index, zone] of readZones(exclusions).entries()) {
+    const place = numbered('exclusion', 'Excluded zone', index);
     if (!isNumber(zone.from) || !isNumber(zone.to) || zone.from >= zone.to) {
-      problems.push(problem('error', zoneWhere, 'From is not below to.'));
+      problems.push(problem('error', place, 'From is not below to.'));
     }
     if (zone.ignore === true) {
       problems.push(
         problem(
           'warning',
-          zoneWhere,
+          place,
           'Hidden only from the chart: the zone is still dropped from the data.',
         ),
       );
@@ -92,16 +95,12 @@ function postProcessingProblems(settings: SpectraSettings): SettingsProblem[] {
   const { filters, scale, ranges, calculations } = settings.postProcessing;
 
   for (const [index, step] of (filters ?? []).entries()) {
-    const where = `Matrix step ${String(index + 1)}`;
-    if (
-      step.name !== undefined &&
-      step.name !== '' &&
-      !MATRIX_FILTER_NAMES.includes(step.name as MatrixFilterName)
-    ) {
+    const { name } = step;
+    if (name !== undefined && name !== '' && !isMatrixFilterName(name)) {
       problems.push(
         problem(
           'error',
-          where,
+          numbered('matrix', 'Matrix step', index),
           `The matrix stage only knows ${MATRIX_FILTER_NAMES.join(', ')}; it throws on anything else.`,
         ),
       );
@@ -112,12 +111,12 @@ function postProcessingProblems(settings: SpectraSettings): SettingsProblem[] {
   if (
     method !== undefined &&
     method !== '' &&
-    !SCALE_METHODS.includes(method.toLowerCase() as ScaleMethod)
+    !isScaleMethod(method.toLowerCase())
   ) {
     problems.push(
       problem(
         'error',
-        'Scaling',
+        SCALING,
         `Unknown scaling: ${method}. It throws on anything but ${SCALE_METHODS.join(', ')}.`,
       ),
     );
@@ -126,7 +125,7 @@ function postProcessingProblems(settings: SpectraSettings): SettingsProblem[] {
     problems.push(
       problem(
         'warning',
-        'Scaling',
+        SCALING,
         'The difference is taken against the first spectrum the processor holds, which is not necessarily one of those selected.',
       ),
     );
@@ -134,53 +133,53 @@ function postProcessingProblems(settings: SpectraSettings): SettingsProblem[] {
 
   const labels = new Set<string>();
   for (const [index, range] of (ranges ?? []).entries()) {
-    const where = `Range ${String(index + 1)}`;
+    const place = numbered('range', 'Range', index);
     const label = range.label ?? '';
     if (label === '') {
       problems.push(
-        problem('error', where, 'A range with no name is silently skipped.'),
+        problem('error', place, 'A range with no name is silently skipped.'),
       );
     } else if (!isUsableLabel(label)) {
       problems.push(
         problem(
           'error',
-          where,
+          place,
           `${label} cannot be the name of a variable, and the calculations read it as one.`,
         ),
       );
     } else if (labels.has(label)) {
       problems.push(
-        problem('error', where, `${label} names two ranges; the second wins.`),
+        problem('error', place, `${label} names two ranges; the second wins.`),
       );
     } else {
       labels.add(label);
     }
     if (isNumber(range.from) && isNumber(range.to) && range.from >= range.to) {
-      problems.push(problem('error', where, 'From is not below to.'));
+      problems.push(problem('error', place, 'From is not below to.'));
     }
   }
 
   for (const [index, calculation] of (calculations ?? []).entries()) {
-    const where = `Calculation ${String(index + 1)}`;
+    const place = numbered('calculation', 'Calculation', index);
     if (!isUsableLabel(calculation.label)) {
       problems.push(
         problem(
           'error',
-          where,
+          place,
           'A calculation needs a name that can be a variable.',
         ),
       );
     }
     const complaint = calculationProblem(calculation.formula, labels);
     if (complaint !== undefined) {
-      problems.push(problem('error', where, complaint));
+      problems.push(problem('error', place, complaint));
     }
   }
   if ((calculations ?? []).length > 0 && labels.size === 0) {
     problems.push(
       problem(
         'error',
-        'Calculations',
+        CALCULATIONS,
         'A calculation reads the range integrals, and no range is named.',
       ),
     );
@@ -188,6 +187,21 @@ function postProcessingProblems(settings: SpectraSettings): SettingsProblem[] {
   return problems;
 }
 
+/**
+ * The place of one entry of a listed part, labelled as the panel numbers it.
+ * @param part - Which part of the settings.
+ * @param label - What one entry of it is called.
+ * @param index - Which entry, counting from zero.
+ * @returns The place, labelled counting from one.
+ */
+function numbered(
+  part: ProblemPlace['part'],
+  label: string,
+  index: number,
+): ProblemPlace {
+  return { part, index, where: `${label} ${String(index + 1)}` };
+}
+
 /**
  * What is wrong with a calculation, as far as can be told without running it.
  * @param formula - What the reader typed.
@@ -200,13 +214,8 @@ function calculationProblem(
 ): string | undefined {
   const trimmed = formula.trim();
   if (trimmed === '') return 'The formula is empty.';
-  let depth = 0;
-  for (const character of trimmed) {
-    if (character === '(') depth++;
-    if (character === ')') depth--;
-    if (depth < 0) return 'A closing bracket has nothing to close.';
-  }
-  if (depth > 0) return 'A bracket is left open.';
+  const unbalanced = bracketProblem(trimmed);
+  if (unbalanced !== undefined) return unbalanced;
 
   // The lookbehind keeps the exponent of a number such as `1e3` from reading
   // as the name of a range.

package/src/spectra/core/stepProblems.ts

@@ -1,5 +1,5 @@
 import { filterOptions, readFilterOption } from './filterChain.ts';
-import type { SettingsProblem } from './problems.ts';
+import type { ProblemPlace, SettingsProblem } from './problems.ts';
 import {
   formulaProblem,
   isNumber,
@@ -7,6 +7,7 @@ import {
   problem,
 } from './problems.ts';
 import type { SpectrumFilter } from './settings.ts';
+import { isSpan, readZones } from './zones.ts';
 
 /** Where a Savitzky–Golay window and degree can sit inside a step's options. */
 const WINDOW_PREFIXES: readonly string[] = ['', 'gsd.sgOptions.'];
@@ -17,34 +18,34 @@ const WINDOW_PREFIXES: readonly string[] = ['', 'gsd.sgOptions.'];
  * Every rule here is one the processor actually fails on, checked against what
  * `filterXY` does rather than against what the option is called.
  * @param step - The step.
- * @param where - How the panel labels it.
+ * @param place - Which step of the chain it is, and how the panel labels it.
  * @returns Its problems.
  */
 export function stepProblems(
   step: SpectrumFilter,
-  where: string,
+  place: ProblemPlace,
 ): SettingsProblem[] {
   const problems: SettingsProblem[] = [];
   const from = readFilterOption(step, 'from');
   const to = readFilterOption(step, 'to');
   if (isNumber(from) && isNumber(to) && from >= to) {
-    problems.push(problem('error', where, 'From is not below to.'));
+    problems.push(problem('error', place, 'From is not below to.'));
   }
 
   problems.push(
-    ...smoothingProblems(step, where),
-    ...zoneProblems(step, where),
+    ...smoothingProblems(step, place),
+    ...zoneProblems(step, place),
   );
 
   const points = readFilterOption(step, 'numberOfPoints');
   if (points !== undefined && (!isWholeNumber(points) || points < 2)) {
-    problems.push(problem('error', where, 'A grid needs at least two points.'));
+    problems.push(problem('error', place, 'A grid needs at least two points.'));
   }
 
   const peaks = readFilterOption(step, 'nbPeaks');
   if (peaks !== undefined && (!isWholeNumber(peaks) || peaks < 1)) {
     problems.push(
-      problem('error', where, 'At least one peak has to be looked for.'),
+      problem('error', place, 'At least one peak has to be looked for.'),
     );
   }
 
@@ -52,7 +53,7 @@ export function stepProblems(
   const maximum = readFilterOption(step, 'max');
   if (isNumber(minimum) && isNumber(maximum) && minimum >= maximum) {
     problems.push(
-      problem('error', where, 'The minimum is not below the maximum.'),
+      problem('error', place, 'The minimum is not below the maximum.'),
     );
   }
 
@@ -64,7 +65,7 @@ export function stepProblems(
       variable,
     );
     if (complaint !== undefined) {
-      problems.push(problem('error', where, complaint));
+      problems.push(problem('error', place, complaint));
     }
   }
 
@@ -74,7 +75,7 @@ export function stepProblems(
       problems.push(
         problem(
           'warning',
-          where,
+          place,
           'Both an x value and a point number are given; the point number wins and the x value is ignored.',
         ),
       );
@@ -89,12 +90,12 @@ export function stepProblems(
  * `calibrateX` carries a second pair under its peak picking, and the processor
  * throws on an even window there exactly as it does on the plain one.
  * @param step - The step.
- * @param where - How the panel labels it.
+ * @param place - Which step it is.
  * @returns Its problems.
  */
 function smoothingProblems(
   step: SpectrumFilter,
-  where: string,
+  place: ProblemPlace,
 ): SettingsProblem[] {
   const problems: SettingsProblem[] = [];
   for (const prefix of WINDOW_PREFIXES) {
@@ -107,7 +108,7 @@ function smoothingProblems(
       problems.push(
         problem(
           'error',
-          where,
+          place,
           'The window must be an odd whole number of 5 or more.',
         ),
       );
@@ -119,7 +120,7 @@ function smoothingProblems(
       problems.push(
         problem(
           'error',
-          where,
+          place,
           'The polynomial degree must be a whole number of 1 or more.',
         ),
       );
@@ -132,7 +133,7 @@ function smoothingProblems(
       problems.push(
         problem(
           'error',
-          where,
+          place,
           'The polynomial degree must stay below the window size.',
         ),
       );
@@ -147,7 +148,7 @@ function smoothingProblems(
     problems.push(
       problem(
         'error',
-        where,
+        place,
         'The derivative must be a whole number of zero or more.',
       ),
     );
@@ -160,69 +161,52 @@ function smoothingProblems(
  *
  * A zone left half filled is not harmless: the processor drops it while
  * normalizing, then reads the first of the zones that are left — so `filterX`
- * throws, and `equallySpaced` hands back a spectrum of no points at all.
+ * throws, and `equallySpaced` hands back a spectrum of no points at all. The
+ * zones are numbered on the list `readZones` reads, which is the list the
+ * editor draws its rows from.
  * @param step - The step.
- * @param where - How the panel labels it.
+ * @param place - Which step it is.
  * @returns Its problems.
  */
-function zoneProblems(step: SpectrumFilter, where: string): SettingsProblem[] {
+function zoneProblems(
+  step: SpectrumFilter,
+  place: ProblemPlace,
+): SettingsProblem[] {
   const problems: SettingsProblem[] = [];
-  const zones = readFilterOption(step, 'zones');
-  const exclusions = readFilterOption(step, 'exclusions');
+  const zones = readZones(readFilterOption(step, 'zones'));
+  const exclusions = readZones(readFilterOption(step, 'exclusions'));
 
-  for (const [index, zone] of asZones(zones).entries()) {
+  for (const [index, zone] of zones.entries()) {
     if (!isSpan(zone)) {
       problems.push(
         problem(
           'error',
-          where,
+          place,
           `Zone to keep ${String(index + 1)} needs both bounds, with from below to; the processor fails on a half-filled one.`,
         ),
       );
     }
   }
-  for (const [index, zone] of asZones(exclusions).entries()) {
+  for (const [index, zone] of exclusions.entries()) {
     if (!isSpan(zone)) {
       problems.push(
         problem(
           'warning',
-          where,
+          place,
           `Zone to drop ${String(index + 1)} needs both bounds, with from below to; as it stands it is ignored.`,
         ),
       );
     }
   }
 
-  if (asZones(zones).length > 0 && asZones(exclusions).length > 0) {
+  if (zones.length > 0 && exclusions.length > 0) {
     problems.push(
       problem(
         'warning',
-        where,
+        place,
         'Zones to keep and zones to drop are both given; the zones to drop win.',
       ),
     );
   }
   return problems;
 }
-
-/**
- * A step's option read as a list of stretches.
- * @param value - What the option holds.
- * @returns The list, empty when the option holds anything else.
- */
-function asZones(value: unknown): ReadonlyArray<Record<string, unknown>> {
-  if (!Array.isArray(value)) return [];
-  return value.filter(
-    (entry): entry is Record<string, unknown> =>
-      typeof entry === 'object' && entry !== null,
-  );
-}
-
-/**
- * Whether a stretch names both of its ends, the right way round.
- * @param zone - One entry of a zone list.
- * @returns True when the processor can use it.
- */
-function isSpan(zone: Record<string, unknown>): boolean {
-  return isNumber(zone.from) && isNumber(zone.to) && zone.from < zone.to;
-}

package/src/spectra/core/zones.ts

@@ -0,0 +1,64 @@
+import { isNumber } from './problems.ts';
+
+/**
+ * One stretch of x as the settings hold it: an exclusion, a zone to keep, a
+ * zone to drop.
+ *
+ * Read as a plain record rather than at upstream's type, because a zone a
+ * reader is halfway through typing — or one pasted in with a bound written as
+ * text — is still a zone the panel has to show, number and let them fix.
+ */
+export type ZoneEntry = Readonly<Record<string, unknown>>;
+
+/**
+ * A setting read as a list of stretches, one entry per row.
+ *
+ * Every entry of the list stays an entry, so the rows the editor draws and the
+ * zones the problems number are the same list, and editing one row can never
+ * write back a list that silently lost another. An entry that is not an object
+ * at all reads as a zone with neither bound, which is what it is to the
+ * processor.
+ * @param value - What the settings hold under the key.
+ * @returns The zones, empty when the value is not a list.
+ */
+export function readZones(value: unknown): ZoneEntry[] {
+  if (!Array.isArray(value)) return [];
+  const entries: readonly unknown[] = value;
+  const zones: ZoneEntry[] = [];
+  for (const entry of entries) {
+    zones.push(isZoneEntry(entry) ? entry : {});
+  }
+  return zones;
+}
+
+/**
+ * One end of a stretch, as a number box can show it.
+ * @param zone - One entry of a zone list.
+ * @param end - Which end.
+ * @returns The bound, or undefined when it is missing or not a number.
+ */
+export function zoneBound(
+  zone: ZoneEntry,
+  end: 'from' | 'to',
+): number | undefined {
+  const bound = zone[end];
+  return typeof bound === 'number' ? bound : undefined;
+}
+
+/**
+ * Whether a stretch names both of its ends, the right way round.
+ * @param zone - One entry of a zone list.
+ * @returns True when the processor can use it.
+ */
+export function isSpan(zone: ZoneEntry): boolean {
+  return isNumber(zone.from) && isNumber(zone.to) && zone.from < zone.to;
+}
+
+/**
+ * Whether one entry of the list can be read as a record of bounds.
+ * @param entry - One entry of the list.
+ * @returns True when it is an object.
+ */
+function isZoneEntry(entry: unknown): entry is ZoneEntry {
+  return typeof entry === 'object' && entry !== null;
+}