react-cheminfo 0.58.0 → 0.60.0

package/src/locales/es.json

@@ -107,10 +107,11 @@
   "about.providedBy": "Ofrecido por",
   "about.whatYouCanDo": "Lo que puede hacer aquí",
   "about.builtOn": "Construido sobre",
+  "about.buildVersion": "Versión {version}",
+  "about.buildBuilt": "Compilado",
+  "about.buildCommit": "Commit",
   "about.howToCite": "Cómo citar",
   "about.citeWork": "Citar {what}",
-  "about.built": "Compilado {builtAt}.",
-  "about.builtFromCommit": "Compilado {builtAt} desde el commit {commit}.",
   "about.nameList": "{names} y {last}",
   "help.label": "Ayuda",
   "help.learnMore": "Saber más",
@@ -593,5 +594,37 @@
   "taxonomy.rank.noRank": "sin rango",
   "taxonomy.rank.clade": "clado",
   "taxonomy.rank.cellularRoot": "raíz celular",
-  "taxonomy.rank.acellularRoot": "raíz acelular"
+  "taxonomy.rank.acellularRoot": "raíz acelular",
+  "moleculesToken.title": "Tokens para molecules.cheminfo.org",
+  "moleculesToken.checkedAt": "Comprobados el {when}",
+  "moleculesToken.checkAgain": "Comprobar de nuevo",
+  "moleculesToken.notChecked": "Aún sin comprobar: el servicio que escribe en molecules.cheminfo.org comprueba sus tokens al arrancar.",
+  "moleculesToken.column.variable": "Variable",
+  "moleculesToken.column.source": "Fuente",
+  "moleculesToken.column.status": "Estado",
+  "moleculesToken.column.details": "Detalles",
+  "moleculesToken.anySource": "cualquier fuente",
+  "moleculesToken.verdict.ok": "válido",
+  "moleculesToken.verdict.otherSource": "de otra fuente",
+  "moleculesToken.verdict.refused": "rechazado",
+  "moleculesToken.verdict.unset": "sin definir",
+  "moleculesToken.verdict.uncheckable": "no comprobable",
+  "moleculesToken.verdict.unanswered": "sin respuesta",
+  "moleculesToken.forSource": "para {source}",
+  "moleculesToken.issued": "emitido el {when}",
+  "moleculesToken.issuedTo": "emitido para {email} el {when}",
+  "moleculesToken.lastUsed": "usado por última vez el {when}",
+  "moleculesToken.neverUsed": "nunca usado",
+  "moleculesToken.otherSourceDetail": "emitido para {source}: lo que envía se atribuye a esa fuente",
+  "moleculesToken.refusedDetail": "nunca emitido, o revocado",
+  "moleculesToken.unsetDetail": "Defina {variable} en el .env del servidor.",
+  "moleculesToken.uncheckableDetail": "Este molecules.cheminfo.org aún no puede comprobar un token.",
+  "moleculesToken.howToChange": "Un token se cambia en el .env del servidor y se vuelve a leer cuando el servicio se reinicia. molecules.cheminfo.org emite uno nuevo con",
+  "moleculesToken.fix.title": "Defina un token válido en {variables}",
+  "moleculesToken.fix.issueOne": "Emita un token en la página Admin de molecules.cheminfo.org:",
+  "moleculesToken.fix.issueMany": "Emita un token por fuente en la página Admin de molecules.cheminfo.org:",
+  "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:"
 }

package/src/locales/fr.json

@@ -107,10 +107,11 @@
   "about.providedBy": "Proposé par",
   "about.whatYouCanDo": "Ce que vous pouvez faire ici",
   "about.builtOn": "Construit sur",
+  "about.buildVersion": "Version {version}",
+  "about.buildBuilt": "Compilé",
+  "about.buildCommit": "Commit",
   "about.howToCite": "Comment citer",
   "about.citeWork": "Citer {what}",
-  "about.built": "Compilé {builtAt}.",
-  "about.builtFromCommit": "Compilé {builtAt} depuis le commit {commit}.",
   "about.nameList": "{names} et {last}",
   "help.label": "Aide",
   "help.learnMore": "En savoir plus",
@@ -593,5 +594,37 @@
   "taxonomy.rank.noRank": "sans rang",
   "taxonomy.rank.clade": "clade",
   "taxonomy.rank.cellularRoot": "racine cellulaire",
-  "taxonomy.rank.acellularRoot": "racine acellulaire"
+  "taxonomy.rank.acellularRoot": "racine acellulaire",
+  "moleculesToken.title": "Jetons pour molecules.cheminfo.org",
+  "moleculesToken.checkedAt": "Vérifiés le {when}",
+  "moleculesToken.checkAgain": "Vérifier à nouveau",
+  "moleculesToken.notChecked": "Pas encore vérifiés : le service qui écrit dans molecules.cheminfo.org vérifie ses jetons à son démarrage.",
+  "moleculesToken.column.variable": "Variable",
+  "moleculesToken.column.source": "Source",
+  "moleculesToken.column.status": "État",
+  "moleculesToken.column.details": "Détails",
+  "moleculesToken.anySource": "n'importe quelle source",
+  "moleculesToken.verdict.ok": "valide",
+  "moleculesToken.verdict.otherSource": "d'une autre source",
+  "moleculesToken.verdict.refused": "refusé",
+  "moleculesToken.verdict.unset": "non défini",
+  "moleculesToken.verdict.uncheckable": "invérifiable",
+  "moleculesToken.verdict.unanswered": "pas de réponse",
+  "moleculesToken.forSource": "pour {source}",
+  "moleculesToken.issued": "émis le {when}",
+  "moleculesToken.issuedTo": "émis pour {email} le {when}",
+  "moleculesToken.lastUsed": "dernière utilisation le {when}",
+  "moleculesToken.neverUsed": "jamais utilisé",
+  "moleculesToken.otherSourceDetail": "émis pour {source} : ce qu'il envoie est attribué à cette source",
+  "moleculesToken.refusedDetail": "jamais émis, ou révoqué",
+  "moleculesToken.unsetDetail": "Définissez {variable} dans le fichier .env du serveur.",
+  "moleculesToken.uncheckableDetail": "Ce molecules.cheminfo.org ne sait pas encore vérifier un jeton.",
+  "moleculesToken.howToChange": "Un jeton se change dans le fichier .env du serveur, et est relu au redémarrage du service. molecules.cheminfo.org en émet un nouveau avec",
+  "moleculesToken.fix.title": "Définissez un jeton valide dans {variables}",
+  "moleculesToken.fix.issueOne": "Émettez un jeton sur la page Admin de molecules.cheminfo.org :",
+  "moleculesToken.fix.issueMany": "Émettez un jeton par source sur la page Admin de molecules.cheminfo.org :",
+  "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 :"
 }

package/src/locales/it.json

@@ -107,10 +107,11 @@
   "about.providedBy": "Offerto da",
   "about.whatYouCanDo": "Cosa si può fare qui",
   "about.builtOn": "Costruito su",
+  "about.buildVersion": "Versione {version}",
+  "about.buildBuilt": "Compilato",
+  "about.buildCommit": "Commit",
   "about.howToCite": "Come citare",
   "about.citeWork": "Citare {what}",
-  "about.built": "Compilato {builtAt}.",
-  "about.builtFromCommit": "Compilato {builtAt} dal commit {commit}.",
   "about.nameList": "{names} e {last}",
   "credits.openbabel.description": "legge e scrive i formati di file chimici, ed esegue la conversione stessa.",
   "credits.openchemlib.description": "legge e scrive strutture, e ne calcola le proprietà nel browser.",
@@ -593,5 +594,37 @@
   "taxonomy.rank.noRank": "senza rango",
   "taxonomy.rank.clade": "clade",
   "taxonomy.rank.cellularRoot": "radice cellulare",
-  "taxonomy.rank.acellularRoot": "radice acellulare"
+  "taxonomy.rank.acellularRoot": "radice acellulare",
+  "moleculesToken.title": "Token per molecules.cheminfo.org",
+  "moleculesToken.checkedAt": "Verificati il {when}",
+  "moleculesToken.checkAgain": "Verifica di nuovo",
+  "moleculesToken.notChecked": "Non ancora verificati: il servizio che scrive in molecules.cheminfo.org verifica i suoi token all'avvio.",
+  "moleculesToken.column.variable": "Variabile",
+  "moleculesToken.column.source": "Fonte",
+  "moleculesToken.column.status": "Stato",
+  "moleculesToken.column.details": "Dettagli",
+  "moleculesToken.anySource": "qualsiasi fonte",
+  "moleculesToken.verdict.ok": "valido",
+  "moleculesToken.verdict.otherSource": "di un'altra fonte",
+  "moleculesToken.verdict.refused": "rifiutato",
+  "moleculesToken.verdict.unset": "non impostato",
+  "moleculesToken.verdict.uncheckable": "non verificabile",
+  "moleculesToken.verdict.unanswered": "nessuna risposta",
+  "moleculesToken.forSource": "per {source}",
+  "moleculesToken.issued": "emesso il {when}",
+  "moleculesToken.issuedTo": "emesso per {email} il {when}",
+  "moleculesToken.lastUsed": "usato l'ultima volta il {when}",
+  "moleculesToken.neverUsed": "mai usato",
+  "moleculesToken.otherSourceDetail": "emesso per {source}: ciò che invia è attribuito a quella fonte",
+  "moleculesToken.refusedDetail": "mai emesso, o revocato",
+  "moleculesToken.unsetDetail": "Impostare {variable} nel file .env del server.",
+  "moleculesToken.uncheckableDetail": "Questo molecules.cheminfo.org non sa ancora verificare un token.",
+  "moleculesToken.howToChange": "Un token si cambia nel file .env del server e viene riletto al riavvio del servizio. molecules.cheminfo.org ne emette uno nuovo con",
+  "moleculesToken.fix.title": "Impostare un token valido in {variables}",
+  "moleculesToken.fix.issueOne": "Emettere un token nella pagina Admin di molecules.cheminfo.org:",
+  "moleculesToken.fix.issueMany": "Emettere un token per fonte nella pagina Admin di molecules.cheminfo.org:",
+  "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:"
 }

package/src/moleculesSources/core/index.ts

@@ -0,0 +1,11 @@
+export type {
+  FetchSourceLooksOptions,
+  SourceLook,
+  SourceLooks,
+} from './moleculesSources.ts';
+export {
+  MOLECULES_URL,
+  fetchSourceLooks,
+  readSourceLooks,
+  sourceLook,
+} from './moleculesSources.ts';

package/src/moleculesSources/core/moleculesSources.ts

@@ -0,0 +1,102 @@
+/** Where molecules.cheminfo.org answers, which holds the family's sources. */
+export const MOLECULES_URL = 'https://molecules.cheminfo.org';
+
+/**
+ * How a source is drawn wherever the family names it — PubChem, ChEBI, COCONUT
+ * — as molecules.cheminfo.org publishes it. molecules is where a source's
+ * colour and logo are kept and edited, so every site reads them from there
+ * rather than keeping a copy that drifts the first time one is changed.
+ */
+export interface SourceLook {
+  /** What the source is called, as molecules writes it: `ChEBI`. */
+  name: string;
+  /** The colour its badges are drawn in, as `#rrggbb`; null for none. */
+  color: string | null;
+  /** The absolute address of its little logo; null when it has none. */
+  logo: string | null;
+}
+
+/** Every source molecules publishes, by its name in lower case. */
+export type SourceLooks = ReadonlyMap<string, SourceLook>;
+
+/**
+ * The sources a `/v1/sources` answer describes, each logo made absolute
+ * against the address it was read from, so the badge draws it on any site.
+ * Anything not shaped like a source is left out rather than trusted.
+ * @param body - The parsed answer of `/v1/sources`.
+ * @param baseUrl - Where it was read from.
+ * @returns The looks, by lower-case name.
+ */
+export function readSourceLooks(body: unknown, baseUrl: string): SourceLooks {
+  const looks = new Map<string, SourceLook>();
+  const sources = isRecord(body) ? body.sources : undefined;
+  if (!Array.isArray(sources)) return looks;
+  for (const source of sources) {
+    if (!isRecord(source) || typeof source.name !== 'string') continue;
+    const { name, color, logo } = source;
+    looks.set(name.toLowerCase(), {
+      name,
+      color: typeof color === 'string' && HEX_COLOR.test(color) ? color : null,
+      logo: typeof logo === 'string' ? absolute(logo, baseUrl) : null,
+    });
+  }
+  return looks;
+}
+
+/**
+ * The look of one source, named in any case.
+ * @param looks - What molecules publishes, or null while it is being read.
+ * @param name - The source's name or key: `chebi`, `ChEBI`.
+ * @returns Its look, or `undefined` when molecules does not know it (yet).
+ */
+export function sourceLook(
+  looks: SourceLooks | null,
+  name: string,
+): SourceLook | undefined {
+  return looks?.get(name.toLowerCase());
+}
+
+/** Where and how {@link fetchSourceLooks} reads. */
+export interface FetchSourceLooksOptions {
+  /**
+   * Where molecules answers.
+   * @default MOLECULES_URL
+   */
+  url?: string;
+  /**
+   * Aborts the read.
+   * @default undefined
+   */
+  signal?: AbortSignal;
+}
+
+/**
+ * Read every source's look from molecules.cheminfo.org.
+ * @param options - See {@link FetchSourceLooksOptions}.
+ * @returns The looks, by lower-case name.
+ * @throws {Error} When molecules does not answer, or answers with an error.
+ */
+export async function fetchSourceLooks(
+  options: FetchSourceLooksOptions = {},
+): Promise<SourceLooks> {
+  const { url = MOLECULES_URL, signal } = options;
+  const response = await fetch(`${url}/v1/sources`, { signal });
+  if (!response.ok) {
+    throw new Error(`${url} answered ${response.status} for its sources`);
+  }
+  return readSourceLooks(await response.json(), url);
+}
+
+const HEX_COLOR = /^#[\da-f]{6}$/i;
+
+function absolute(address: string, baseUrl: string): string | null {
+  try {
+    return new URL(address, baseUrl).href;
+  } catch {
+    return null;
+  }
+}
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return typeof value === 'object' && value !== null;
+}

package/src/moleculesSources/ui/MoleculesSourceBadge.tsx

@@ -0,0 +1,44 @@
+import type { ReactElement } from 'react';
+
+import { MOLECULES_URL, sourceLook } from '../core/moleculesSources.ts';
+
+import type { SourceBadgeProps } from './SourceBadge.tsx';
+import { SourceBadge } from './SourceBadge.tsx';
+import { useSourceLooks } from './useSourceLooks.ts';
+
+export interface MoleculesSourceBadgeProps extends Omit<
+  SourceBadgeProps,
+  'color' | 'logo'
+> {
+  /**
+   * Where molecules answers, for a site that reads another instance.
+   * @default MOLECULES_URL
+   */
+  moleculesUrl?: string;
+}
+
+/**
+ * A source named by a site that does not keep its look: the colour and the
+ * logo come from molecules.cheminfo.org, where they are edited. A source
+ * molecules does not know — or until it has answered — is drawn neutral.
+ * @param props - The source, by its name in any case, and the entry it holds.
+ * @returns The badge.
+ */
+export function MoleculesSourceBadge(
+  props: MoleculesSourceBadgeProps,
+): ReactElement {
+  const { moleculesUrl = MOLECULES_URL, ...badge } = props;
+  const look = sourceLook(useSourceLooks(moleculesUrl), badge.name);
+  if (look === undefined) return <SourceBadge {...badge} />;
+
+  return (
+    <SourceBadge
+      {...badge}
+      label={badge.label ?? look.name}
+      // A source molecules draws in no colour of its own is drawn neutral
+      // here: the site naming it is not that source.
+      color={look.color ?? undefined}
+      logo={look.logo}
+    />
+  );
+}

package/src/moleculesSources/ui/SourceBadge.tsx

@@ -0,0 +1,117 @@
+import type { CSSProperties, ReactElement, ReactNode } from 'react';
+
+export interface SourceBadgeProps {
+  /** What the source is called, read in the badge's tooltip. */
+  name: string;
+  /**
+   * What the badge says.
+   * @default name
+   */
+  label?: ReactNode;
+  /**
+   * The source's own colour, as `#rrggbb`. `null` draws it in the site's own
+   * colour, which is how a site marks a source that is itself.
+   * @default undefined — a neutral grey, for a source with no look
+   */
+  color?: string | null;
+  /**
+   * The absolute address of its little logo.
+   * @default null
+   */
+  logo?: string | null;
+  /**
+   * The entry's identifier there, written after the name.
+   * @default null
+   */
+  identifier?: string | null;
+  /**
+   * How many entries the source holds, written after the name when more than
+   * one.
+   * @default 1
+   */
+  count?: number;
+  /**
+   * Where the badge leads, opened in a new tab.
+   * @default null — the badge names the source and leads nowhere
+   */
+  href?: string | null;
+  /**
+   * The tooltip.
+   * @default the name, then the identifier
+   */
+  title?: string;
+  /**
+   * The smaller badge of a dense list, whose identifier goes in the tooltip
+   * only.
+   * @default false
+   */
+  compact?: boolean;
+}
+
+/**
+ * A source, as a badge: its name in its own colour, its little logo on a white
+ * chip, and the entry it holds — the same badge on every site of the family
+ * that names where a molecule comes from.
+ * @param props - See {@link SourceBadgeProps}.
+ * @returns The badge.
+ */
+export function SourceBadge(props: SourceBadgeProps): ReactElement {
+  const {
+    name,
+    label = name,
+    color,
+    logo = null,
+    identifier = null,
+    count = 1,
+    href = null,
+    compact = false,
+  } = props;
+  const title =
+    props.title ?? (identifier === null ? name : `${name} ${identifier}`);
+  const className = [
+    'source-badge',
+    compact ? 'source-badge--compact' : '',
+    color === undefined ? 'source-badge--neutral' : '',
+  ]
+    .filter(Boolean)
+    .join(' ');
+  // A source with no colour of its own takes the site's, from the stylesheet.
+  const style =
+    typeof color === 'string'
+      ? ({ '--source': color } as CSSProperties)
+      : undefined;
+  const content = (
+    <>
+      {logo === null ? null : (
+        <span className="source-badge__logo">
+          <img src={logo} alt="" />
+        </span>
+      )}
+      <span className="source-badge__name">{label}</span>
+      {compact || identifier === null ? null : (
+        <span className="source-badge__id">{identifier}</span>
+      )}
+      {count > 1 ? <span className="source-badge__count">{count}</span> : null}
+    </>
+  );
+
+  if (href === null) {
+    return (
+      <span className={className} style={style} title={title}>
+        {content}
+      </span>
+    );
+  }
+  return (
+    <a
+      className={className}
+      style={style}
+      href={href}
+      target="_blank"
+      rel="noopener noreferrer"
+      title={title}
+    >
+      {content}
+    </a>
+  );
+}

package/src/moleculesSources/ui/index.ts

@@ -0,0 +1,6 @@
+export type { MoleculesSourceBadgeProps } from './MoleculesSourceBadge.tsx';
+export { MoleculesSourceBadge } from './MoleculesSourceBadge.tsx';
+export type { SourceBadgeProps } from './SourceBadge.tsx';
+export { SourceBadge } from './SourceBadge.tsx';
+export type { SourceLooksStore } from './useSourceLooks.ts';
+export { sourceLooksStore, useSourceLooks } from './useSourceLooks.ts';

package/src/moleculesSources/ui/useSourceLooks.ts

@@ -0,0 +1,70 @@
+import { useSyncExternalStore } from 'react';
+
+import type { SourceLooks } from '../core/moleculesSources.ts';
+import { MOLECULES_URL, fetchSourceLooks } from '../core/moleculesSources.ts';
+
+/**
+ * Every source's look, read from molecules.cheminfo.org once per page however
+ * many badges ask for it.
+ * @param url - Where molecules answers.
+ * @returns The looks by lower-case name, or null until molecules has answered;
+ * an empty map when it could not be read, so the badges stop waiting and stay
+ * neutral.
+ */
+export function useSourceLooks(
+  url: string = MOLECULES_URL,
+): SourceLooks | null {
+  const store = sourceLooksStore(url);
+  return useSyncExternalStore(store.subscribe, store.read, notYet);
+}
+
+/** The one read of a molecules address, shared by every badge on the page. */
+export interface SourceLooksStore {
+  /** Follow the read, starting it on the first call. */
+  subscribe: (listener: () => void) => () => void;
+  /** What has been read so far. */
+  read: () => SourceLooks | null;
+}
+
+/**
+ * The store behind {@link useSourceLooks}: one per address, read once.
+ * @param url - Where molecules answers.
+ * @returns The store.
+ */
+export function sourceLooksStore(url: string): SourceLooksStore {
+  let store = STORES.get(url);
+  if (store === undefined) {
+    store = createStore(url);
+    STORES.set(url, store);
+  }
+  return store;
+}
+
+const STORES = new Map<string, SourceLooksStore>();
+
+function createStore(url: string): SourceLooksStore {
+  let looks: SourceLooks | null = null;
+  let started = false;
+  const listeners = new Set<() => void>();
+
+  function settle(value: SourceLooks): void {
+    looks = value;
+    for (const listener of listeners) listener();
+  }
+
+  return {
+    subscribe(listener) {
+      listeners.add(listener);
+      if (!started) {
+        started = true;
+        fetchSourceLooks({ url }).then(settle, () => settle(new Map()));
+      }
+      return () => listeners.delete(listener);
+    },
+    read: () => looks,
+  };
+}
+
+function notYet(): null {
+  return null;
+}

package/src/moleculesToken/core/index.ts

@@ -0,0 +1,12 @@
+export type {
+  CheckMoleculesTokenOptions,
+  MoleculesTokenCheck,
+  MoleculesTokenToCheck,
+  MoleculesTokenVerdict,
+} from './moleculesToken.ts';
+export {
+  checkMoleculesToken,
+  checkMoleculesTokens,
+  publicTokenCheck,
+} from './moleculesToken.ts';
+export { issueTokenCommand, tokensToFix } from './tokenFix.ts';