react-cheminfo 0.64.1 → 0.66.0

package/src/locales/fr.json

@@ -53,6 +53,7 @@
   "share.button": "Partager",
   "share.buttonTitle": "Partager un lien vers cette page, ou l'intégrer à votre propre site",
   "share.dialogTitleFor": "Partager ou intégrer — {title}",
+  "share.frameTitle": "{site} — {title}",
   "share.layout": "Disposition",
   "share.embed": "Intégrer dans une autre page",
   "share.embedHint": "Retire l'en-tête du site et sa navigation, pour que la page prenne place dans une page à vous.",
@@ -104,6 +105,12 @@
   "clipboard.copyThe": "Copier {what}",
   "clipboard.copyValue": "Copier {value}",
   "clipboard.copyToClipboard": "Copier dans le presse-papiers",
+  "card.details": "Détails",
+  "card.detailsTitle": "Ouvrir dans un nouvel onglet",
+  "card.detailsLabel": "Détails : ouvrir dans un nouvel onglet",
+  "card.copyTable": "Copier en tableau",
+  "card.copyTableTitle": "Copier le tableau, à coller dans un tableur",
+  "card.copyPicture": "Copier ou enregistrer l’image",
   "about.providedBy": "Proposé par",
   "about.whatYouCanDo": "Ce que vous pouvez faire ici",
   "about.builtOn": "Construit sur",
@@ -245,6 +252,35 @@
   "pedagogy.previous": "Précédent",
   "pedagogy.next": "Suivant",
   "pedagogy.stepOf": "Étape {step} sur {total}",
+  "pedagogy.answerEmpty": "Tapez {what}.",
+  "pedagogy.answerUnreadable": "« {typed} » n’est pas {what}.",
+  "pedagogy.questions": "Questions",
+  "pedagogy.questionsInSeries": "Questions dans une série",
+  "pedagogy.questionCount": "{count} questions",
+  "pedagogy.allQuestions": "Les {count} questions",
+  "pedagogy.newSeries": "Nouvelle série",
+  "pedagogy.newSeriesTitle": "Tirer une autre série ; le lien affiché change avec elle",
+  "pedagogy.seriesQuestions": "Questions de la série",
+  "pedagogy.questionNumber": "Question {number}",
+  "pedagogy.questionOf": "Question {number} sur {total}",
+  "pedagogy.solved": "Résolu",
+  "pedagogy.solvedWithHintsOf": "Indices ouverts : {revealed} sur {total}.",
+  "pedagogy.solvedWithoutHint": "Sans indice.",
+  "pedagogy.nextQuestion": "Question suivante",
+  "pedagogy.solution": "Solution",
+  "pedagogy.exercises": "Exercices",
+  "pedagogy.statusIdle": "pas commencé",
+  "pedagogy.statusAttempted": "rendu, pas encore juste",
+  "pedagogy.statusSolved": "juste",
+  "pedagogy.solvedWithOneHint": "Résolu avec 1 indice",
+  "pedagogy.solvedWithHints": "Résolu avec {count} indices",
+  "formula.copyLabel": "formule",
+  "formula.typeFirst": "Tapez d’abord une formule.",
+  "formula.notElement": "« {symbol} » n’est pas un symbole d’élément.",
+  "formula.noAtom": "« {formula} » ne contient aucun atome.",
+  "formula.wholeCounts": "« {formula} » compte {count} pour un atome ; un nombre d’atomes est entier.",
+  "formula.unknownNotation": "« {formula} » utilise une notation que cet outil ne compte pas.",
+  "formula.unreadable": "« {formula} » n’est pas une formule que cet outil sait lire ({reason}).",
   "slides.exit": "Quitter",
   "slides.previousSlide": "Diapositive précédente",
   "slides.nextSlide": "Diapositive suivante",
@@ -458,6 +494,7 @@
   "structure.tool.unavailable": "Indisponible dans cet éditeur.",
   "structure.loadingEditor": "Chargement de l'éditeur…",
   "structure.export.open": "Exporter la structure",
+  "structure.export.glyph": "Copier ou enregistrer la structure : SMILES, molfile",
   "structure.export.title": "Exporter la structure",
   "structure.export.loading": "Lecture de la structure…",
   "structure.export.nothing": "Rien n'est encore dessiné.",
@@ -626,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é."
 }

package/src/locales/it.json

@@ -53,6 +53,7 @@
   "share.button": "Condividi",
   "share.buttonTitle": "Condividere un link a questa pagina, o incorporarla nel proprio sito",
   "share.dialogTitleFor": "Condividere o incorporare — {title}",
+  "share.frameTitle": "{site} — {title}",
   "share.layout": "Disposizione",
   "share.embed": "Incorporare in un'altra pagina",
   "share.embedHint": "Toglie l'intestazione del sito e la sua navigazione, così la pagina sta dentro una pagina propria.",
@@ -104,6 +105,12 @@
   "clipboard.copyThe": "Copia {what}",
   "clipboard.copyValue": "Copia {value}",
   "clipboard.copyToClipboard": "Copia negli appunti",
+  "card.details": "Dettagli",
+  "card.detailsTitle": "Apri in una nuova scheda",
+  "card.detailsLabel": "Dettagli: apri in una nuova scheda",
+  "card.copyTable": "Copia come tabella",
+  "card.copyTableTitle": "Copia la tabella, da incollare in un foglio di calcolo",
+  "card.copyPicture": "Copia o salva l’immagine",
   "about.providedBy": "Offerto da",
   "about.whatYouCanDo": "Cosa si può fare qui",
   "about.builtOn": "Costruito su",
@@ -245,6 +252,35 @@
   "pedagogy.previous": "Precedente",
   "pedagogy.next": "Successivo",
   "pedagogy.stepOf": "Passo {step} di {total}",
+  "pedagogy.answerEmpty": "Scrivi {what}.",
+  "pedagogy.answerUnreadable": "«{typed}» non è {what}.",
+  "pedagogy.questions": "Domande",
+  "pedagogy.questionsInSeries": "Domande per serie",
+  "pedagogy.questionCount": "{count} domande",
+  "pedagogy.allQuestions": "Tutte le {count} domande",
+  "pedagogy.newSeries": "Nuova serie",
+  "pedagogy.newSeriesTitle": "Estrai un’altra serie; il link sullo schermo cambia con essa",
+  "pedagogy.seriesQuestions": "Domande della serie",
+  "pedagogy.questionNumber": "Domanda {number}",
+  "pedagogy.questionOf": "Domanda {number} di {total}",
+  "pedagogy.solved": "Risolta",
+  "pedagogy.solvedWithHintsOf": "Suggerimenti aperti: {revealed} su {total}.",
+  "pedagogy.solvedWithoutHint": "Senza suggerimenti.",
+  "pedagogy.nextQuestion": "Domanda successiva",
+  "pedagogy.solution": "Soluzione",
+  "pedagogy.exercises": "Esercizi",
+  "pedagogy.statusIdle": "non iniziata",
+  "pedagogy.statusAttempted": "consegnata, non ancora giusta",
+  "pedagogy.statusSolved": "giusta",
+  "pedagogy.solvedWithOneHint": "Risolta con 1 suggerimento",
+  "pedagogy.solvedWithHints": "Risolta con {count} suggerimenti",
+  "formula.copyLabel": "formula",
+  "formula.typeFirst": "Scrivi prima una formula.",
+  "formula.notElement": "«{symbol}» non è il simbolo di un elemento.",
+  "formula.noAtom": "«{formula}» non contiene alcun atomo.",
+  "formula.wholeCounts": "«{formula}» dà a un atomo il numero {count}; i numeri di atomi sono interi.",
+  "formula.unknownNotation": "«{formula}» usa una notazione che questo strumento non conta.",
+  "formula.unreadable": "«{formula}» non è una formula che questo strumento sa leggere ({reason}).",
   "slides.exit": "Esci",
   "slides.previousSlide": "Diapositiva precedente",
   "slides.nextSlide": "Diapositiva successiva",
@@ -402,6 +438,7 @@
   "structure.tool.unavailable": "Non disponibile in questo editor.",
   "structure.loadingEditor": "Caricamento dell'editor…",
   "structure.export.open": "Esporta la struttura",
+  "structure.export.glyph": "Copia o salva la struttura: SMILES, molfile",
   "structure.export.title": "Esporta la struttura",
   "structure.export.loading": "Lettura della struttura…",
   "structure.export.nothing": "Non c'è ancora nulla di disegnato.",
@@ -626,5 +663,24 @@
   "moleculesToken.fix.issueOnServer": "Oppure, sul server di molecules.cheminfo.org:",
   "moleculesToken.fix.envOne": "Scriverlo nel file .env del server di questo sito:",
   "moleculesToken.fix.envMany": "Scriverli nel file .env del server di questo sito:",
-  "moleculesToken.fix.restart": "Riavviare i servizi, che leggono il file .env solo all'avvio:"
+  "moleculesToken.fix.restart": "Riavviare i servizi, che leggono il file .env solo all'avvio:",
+  "ir.mode.intensity": "intensità",
+  "ir.raman.xTitle": "spostamento Raman (cm⁻¹)",
+  "ir.raman.chart": "Spettro Raman letto come intensità, con lo spostamento Raman crescente da sinistra a destra. Trascina sopra per ingrandire l'asse dello spostamento Raman, trascina oltre la linea di base per portare con sé l'asse dell'intensità, gira la rotellina per scalare l'asse dell'intensità e fai doppio clic per riadattare tutto.",
+  "ir.raman.tools": "Strumenti dello spettro Raman",
+  "ir.raman.viewer": "Visualizzatore di spettri Raman",
+  "ir.raman.viewerHelp": "Aiuto del visualizzatore di spettri Raman",
+  "ir.raman.mark": "Visualizzatore Raman",
+  "ir.raman.about": "Informazioni sul visualizzatore Raman",
+  "ir.raman.documentation": "Usare il visualizzatore Raman",
+  "ir.raman.command.documentation": "Come si leggono le bande, e ogni gesto.",
+  "ir.raman.command.readTool": "Un trascinamento restringe l'asse dello spostamento Raman. Rilasciato oltre la linea di base, porta con sé l'asse dell'intensità.",
+  "ir.raman.command.boxTool": "Un trascinamento ingrandisce esattamente il rettangolo che traccia, entrambi gli assi insieme — per guardare dentro una linea di base o una spalla anziché lungo lo spettro.",
+  "ir.raman.command.zoomIn": "Fa emergere le bande deboli, scalando l'asse dell'intensità attorno a zero.",
+  "ir.raman.command.togglePicking": "Trova le bande dello spettro selezionato, le segna sul grafico e le elenca.",
+  "ir.raman.doc.bands": "Le bande dello spettro *selezionato* sono cercate come massimi di intensità, segnate sul grafico ed elencate nel pannello delle bande. Passare su una riga segna la banda sul grafico, e passare sul grafico illumina la riga.",
+  "ir.raman.doc.sampled": "Una banda è data nel punto campionato in cui raggiunge il massimo: la sua posizione non è più precisa della griglia su cui lo spettro è stato registrato.",
+  "ir.raman.aboutLead": "Disegna uno spettro Raman, ne trova le bande e le elenca accanto al grafico.",
+  "ir.raman.credit.picking": "**ir-spectrum** (cheminfo, MIT) trova le bande, con il rilevatore di picchi di **common-spectrum** e **ml-gsd**.",
+  "ir.raman.credit.jcamp": "**convert-to-jcamp** (cheminfo, MIT) scrive il file JCAMP-DX scaricato."
 }

package/src/moleculesClient/core/index.ts

@@ -0,0 +1,19 @@
+export { createMoleculesClient } from './moleculesClient.ts';
+export type {
+  MoleculesClient,
+  MoleculesClientOptions,
+} from './moleculesClientApi.ts';
+export { MoleculesError } from './moleculesClientApi.ts';
+export type {
+  ImportStarted,
+  ImportState,
+  LookupResponse,
+  LookupResult,
+  MoleculeInfo,
+  MoleculeInput,
+  PurgeResponse,
+  RetryDetails,
+  SubmitResponse,
+  SubmitResult,
+  SubmitSummary,
+} from './moleculesTypes.ts';

package/src/moleculesClient/core/moleculesClient.ts

@@ -0,0 +1,175 @@
+import { XSadd } from 'ml-xsadd';
+
+import { trimTrailingSlash } from '../../router/core/address.ts';
+
+import type {
+  MoleculesClient,
+  MoleculesClientOptions,
+} from './moleculesClientApi.ts';
+import { MoleculesError } from './moleculesClientApi.ts';
+import type {
+  ImportStarted,
+  ImportState,
+  LookupResponse,
+  PurgeResponse,
+  SubmitResponse,
+} from './moleculesTypes.ts';
+import {
+  causeOf,
+  gzipBody,
+  messageOf,
+  pause,
+  requestSignal,
+  retryAfter,
+} from './requestRetry.ts';
+
+/** Statuses a request is tried again on: the server is busy or in between. */
+const RETRIED_STATUSES = new Set([429, 502, 503, 504]);
+
+/** The doublings of the pause, after which it stays where it is. */
+const MAX_DOUBLINGS = 20;
+
+/** One request, as it is tried again. */
+interface Call {
+  method: 'GET' | 'POST';
+  path: string;
+  payload: Uint8Array<ArrayBuffer> | undefined;
+  started: number;
+}
+
+/** What one attempt came to: the answer, or why another is worth it. */
+type Outcome<T> =
+  | { answered: true; value: T }
+  | {
+      answered: false;
+      status: number | undefined;
+      reason: string;
+      retryAfterMs: number | undefined;
+    };
+
+/**
+ * A client of the routes a source writes through on molecules.cheminfo.org,
+ * retrying while the server is busy (503), throttling (429), being restarted
+ * (502, 504) or out of reach. Each attempt has its own deadline, the pauses
+ * double with a spread and honour `Retry-After`, and bodies travel gzipped.
+ * Browser-safe: it reads no Node module.
+ * @param options - Where it answers, the token, and how hard to insist.
+ * @returns The client.
+ */
+export function createMoleculesClient(
+  options: MoleculesClientOptions,
+): MoleculesClient {
+  const {
+    token,
+    maxRetryMs = 1_800_000,
+    initialDelayMs = 1000,
+    maxDelayMs = 60_000,
+    requestTimeoutMs = 600_000,
+    signal,
+    onRetry,
+    fetch: fetchImplementation = globalThis.fetch,
+    random = new XSadd().random,
+  } = options;
+  const baseUrl = trimTrailingSlash(options.baseUrl);
+
+  async function attemptOnce<T>(call: Call): Promise<Outcome<T>> {
+    let response: Response;
+    try {
+      response = await fetchImplementation(`${baseUrl}${call.path}`, {
+        method: call.method,
+        headers: {
+          authorization: `Bearer ${token}`,
+          ...(call.payload === undefined
+            ? {}
+            : {
+                'content-type': 'application/json',
+                'content-encoding': 'gzip',
+              }),
+        },
+        body: call.payload,
+        signal: requestSignal(signal, requestTimeoutMs),
+      });
+      if (response.ok) {
+        return { answered: true, value: (await response.json()) as T };
+      }
+    } catch (error: unknown) {
+      if (signal?.aborted) throw signal.reason;
+      return {
+        answered: false,
+        status: undefined,
+        reason: causeOf(error),
+        retryAfterMs: undefined,
+      };
+    }
+    const text = await response.text();
+    const reason = messageOf(text) ?? response.statusText;
+    if (!RETRIED_STATUSES.has(response.status)) {
+      throw new MoleculesError(
+        `${call.method} ${call.path} answered ${response.status}: ${reason}`,
+        response.status,
+        text,
+      );
+    }
+    const asked = retryAfter(response.headers.get('retry-after'), Date.now());
+    return {
+      answered: false,
+      status: response.status,
+      reason,
+      retryAfterMs: asked,
+    };
+  }
+
+  async function attempt<T>(call: Call, number: number): Promise<T> {
+    signal?.throwIfAborted();
+    const outcome = await attemptOnce<T>(call);
+    if (outcome.answered) return outcome.value;
+    const backoff =
+      initialDelayMs *
+      2 ** Math.min(number - 1, MAX_DOUBLINGS) *
+      (0.5 + random() * 0.5);
+    const delayMs = Math.min(maxDelayMs, outcome.retryAfterMs ?? backoff);
+    const elapsed = Date.now() - call.started;
+    if (elapsed + delayMs > maxRetryMs) {
+      throw new MoleculesError(
+        `${call.method} ${call.path} kept failing for ${Math.round(elapsed / 1000)} s: ${outcome.reason}`,
+        outcome.status ?? 0,
+        outcome.reason,
+      );
+    }
+    onRetry?.({
+      method: call.method,
+      path: call.path,
+      attempt: number,
+      status: outcome.status,
+      reason: outcome.reason,
+      delayMs,
+    });
+    await pause(delayMs, signal);
+    return attempt<T>(call, number + 1);
+  }
+
+  async function request<T>(
+    method: 'GET' | 'POST',
+    path: string,
+    body?: unknown,
+  ): Promise<T> {
+    const started = Date.now();
+    const payload =
+      body === undefined ? undefined : await gzipBody(JSON.stringify(body));
+    return attempt<T>({ method, path, payload, started }, 1);
+  }
+
+  return {
+    startImport: () => request<ImportStarted>('POST', '/v1/imports'),
+    importState: () => request<ImportState>('GET', '/v1/imports'),
+    submit: (molecules, { returnInfo = false } = {}) =>
+      request<SubmitResponse>('POST', '/v1/submit', { molecules, returnInfo }),
+    lookup: (queries, kind) =>
+      request<LookupResponse>('POST', '/v1/batch', { queries, kind }),
+    purge: (importKey, { dryRun = false, force = false } = {}) =>
+      request<PurgeResponse>('POST', `/v1/imports/${importKey}/purge`, {
+        dryRun,
+        force,
+      }),
+  };
+}

package/src/moleculesClient/core/moleculesClientApi.ts

@@ -0,0 +1,120 @@
+import type {
+  ImportStarted,
+  ImportState,
+  LookupResponse,
+  MoleculeInput,
+  PurgeResponse,
+  RetryDetails,
+  SubmitResponse,
+} from './moleculesTypes.ts';
+
+/** How a client reaches molecules.cheminfo.org, and how hard it insists. */
+export interface MoleculesClientOptions {
+  /** Where molecules.cheminfo.org answers, e.g. `https://molecules.cheminfo.org`. */
+  baseUrl: string;
+  /** The token issued for the source the client writes for. */
+  token: string;
+  /**
+   * How long one request may keep being retried while the server is busy or
+   * unreachable, in milliseconds.
+   * @default 1_800_000 - half an hour
+   */
+  maxRetryMs?: number;
+  /**
+   * The first pause before a retry; each next one doubles, up to `maxDelayMs`.
+   * @default 1000
+   */
+  initialDelayMs?: number;
+  /**
+   * The longest pause between two attempts, a `Retry-After` included.
+   * @default 60_000
+   */
+  maxDelayMs?: number;
+  /**
+   * How long one attempt may take before it is given up and retried.
+   * @default 600_000
+   */
+  requestTimeoutMs?: number;
+  /**
+   * Stops every request, and every pause between two attempts.
+   * @default undefined - nothing stops them
+   */
+  signal?: AbortSignal;
+  /**
+   * Told about every retry, e.g. to log it.
+   * @default undefined - retries are silent
+   */
+  onRetry?: (details: RetryDetails) => void;
+  /**
+   * The fetch to use, for tests.
+   * @default globalThis.fetch
+   */
+  fetch?: typeof fetch;
+  /**
+   * A number from 0 to 1 that spreads the pauses, so clients that failed
+   * together do not all come back at the same instant.
+   * @default an unseeded `XSadd`
+   */
+  random?: () => number;
+}
+
+/** The routes a source writes through on molecules.cheminfo.org. */
+export interface MoleculesClient {
+  /** Take the source's next import key: the start of a full import. */
+  startImport: () => Promise<ImportStarted>;
+  /** Where the source's import stands. */
+  importState: () => Promise<ImportState>;
+  /**
+   * Send up to 1000 molecules for the source, under its current import key.
+   * @param molecules - Each with its identifier and exactly one notation.
+   * @param options - Whether every answer carries the molecule's properties.
+   * @param options.returnInfo - Ask for them; `false` by default.
+   */
+  submit: (
+    molecules: MoleculeInput[],
+    options?: { returnInfo?: boolean },
+  ) => Promise<SubmitResponse>;
+  /**
+   * Compute up to 1000 molecules without storing anything, for a source
+   * molecules.cheminfo.org imports itself.
+   * @param queries - The structures, all in one notation.
+   * @param kind - The notation.
+   */
+  lookup: (
+    queries: string[],
+    kind: 'smiles' | 'molfile' | 'idCode',
+  ) => Promise<LookupResponse>;
+  /**
+   * Remove the entries an import did not send again.
+   * @param importKey - The key the import took.
+   * @param options - Only count, or remove even more than half.
+   * @param options.dryRun - Only count; `false` by default.
+   * @param options.force - Remove even when that is more than half; `false` by
+   * default.
+   */
+  purge: (
+    importKey: number,
+    options?: { dryRun?: boolean; force?: boolean },
+  ) => Promise<PurgeResponse>;
+}
+
+/** A request molecules.cheminfo.org refused, or that kept failing. */
+export class MoleculesError extends Error {
+  /** The status answered, or 0 when nothing was. */
+  readonly status: number;
+  /** What the server said, as text. */
+  readonly body: string;
+
+  /**
+   * A failed request, with what the server answered.
+   * @param message - What failed, and why.
+   * @param status - The status answered, or 0 when nothing was.
+   * @param body - What the server said.
+   */
+  constructor(message: string, status: number, body: string) {
+    super(message);
+    this.name = 'MoleculesError';
+    this.status = status;
+    this.body = body;
+  }
+}

package/src/moleculesClient/core/moleculesTypes.ts

@@ -0,0 +1,163 @@
+/** One molecule a source sends: its identifier, and exactly one notation. */
+export interface MoleculeInput {
+  /** The source's identifier for it, which its address is written with. */
+  id: string;
+  /**
+   * The structure as SMILES.
+   * @default undefined - another notation is given
+   */
+  smiles?: string;
+  /**
+   * The structure as a molfile.
+   * @default undefined - another notation is given
+   */
+  molfile?: string;
+  /**
+   * The structure as an OpenChemLib idCode.
+   * @default undefined - another notation is given
+   */
+  idCode?: string;
+}
+
+/** What molecules.cheminfo.org computed for a structure. */
+export interface MoleculeInfo {
+  mf: string;
+  mw: number;
+  em: number;
+  charge: number;
+  idCode: string;
+  noStereoID: string;
+  noStereoTautomerID: string;
+  failedTautomerID: number;
+  /** The 512-bit FragFp, sixteen signed 32-bit words. */
+  ssIndex: number[];
+  logS: number;
+  logP: number;
+  acceptorCount: number;
+  donorCount: number;
+  stereoCenterCount: number;
+  rotatableBondCount: number;
+  polarSurfaceArea: number;
+  nbFragments: number;
+  /**
+   * The degree of unsaturation, when the formula has one.
+   * @default undefined
+   */
+  unsaturation?: number;
+  atoms: Record<string, number>;
+  /** The hashes, as 16 hex digits: never JSON numbers, which would round them. */
+  idCodeHash: string;
+  noStereoHash: string;
+  noStereoTautomerHash: string;
+  createdAt: number | null;
+}
+
+/** What became of one molecule a source sent. */
+export interface SubmitResult {
+  id: string | null;
+  /**
+   * The structure it was read as.
+   * @default undefined - it could not be read
+   */
+  idCode?: string;
+  /**
+   * Whether molecules.cheminfo.org held the structure already.
+   * @default undefined - it could not be read
+   */
+  molecule?: 'created' | 'existing';
+  /**
+   * What became of the source's entry.
+   * @default undefined - it could not be read
+   */
+  link?: 'added' | 'unchanged' | 'moved';
+  /**
+   * The computed properties, when they were asked for.
+   * @default undefined
+   */
+  info?: MoleculeInfo;
+  /**
+   * Why the molecule was refused.
+   * @default undefined - it was taken
+   */
+  error?: string;
+}
+
+/** How a batch was taken. */
+export interface SubmitSummary {
+  total: number;
+  /** Molecules new to molecules.cheminfo.org. */
+  created: number;
+  /** Entries new to the source. */
+  added: number;
+  /** Identifiers moved to another structure. */
+  moved: number;
+  unchanged: number;
+  failed: number;
+}
+
+/** What `POST /v1/submit` answers: one result per molecule, in their order. */
+export interface SubmitResponse {
+  source: string;
+  results: SubmitResult[];
+  summary: SubmitSummary;
+}
+
+/** What `POST /v1/imports` answers: the start of a full import. */
+export interface ImportStarted {
+  source: string;
+  importKey: number;
+  importStartedAt: number;
+}
+
+/** What `GET /v1/imports` answers: where the source's import stands. */
+export interface ImportState {
+  source: string;
+  importKey: number;
+  importStartedAt: number | null;
+  updatedAt: number | null;
+  entries: number;
+  stale: number;
+}
+
+/** What a purge answers. */
+export interface PurgeResponse {
+  source: string;
+  importKey: number;
+  dryRun: boolean;
+  /** The entries the import did not send again, removed or to be removed. */
+  removed: number;
+  /** The entries the source holds after. */
+  remaining: number;
+}
+
+/** One answer of `POST /v1/batch`: the molecule a query reads as, or why not. */
+export interface LookupResult {
+  query: string;
+  result: MoleculeInfo | null;
+  /** Whether molecules.cheminfo.org lists it, rather than computing it now. */
+  cached: boolean;
+  /**
+   * Why the query could not be read.
+   * @default undefined - it was read
+   */
+  error?: string;
+}
+
+/** What `POST /v1/batch` answers: one result per query, in their order. */
+export interface LookupResponse {
+  results: LookupResult[];
+}
+
+/** Why a request is tried again, and when. */
+export interface RetryDetails {
+  method: string;
+  path: string;
+  attempt: number;
+  /**
+   * The status that was answered.
+   * @default undefined - nothing was answered
+   */
+  status?: number;
+  reason: string;
+  delayMs: number;
+}