react-cheminfo 0.76.0 → 0.78.0

package/lib/osiris/core/riskDetailRequest.js

@@ -0,0 +1,49 @@
+/**
+ * Asking a worker why one risk came back as it did, and asking again when the
+ * set's cancel took the question with it.
+ *
+ * An explanation travels on a properties channel, and `cancel` drops every
+ * request on every channel — the reader's click included, which then reads as
+ * the channel's own words in place of the findings. It is not part of the set
+ * being abandoned, so it is simply asked for again.
+ *
+ * A channel of its own would be the other way, and is worse here: a channel
+ * makes its worker on the first request, so the first click would wait for
+ * OpenChemLib and the 398 kB of resource tables to load in a cold worker,
+ * where the shared one is already warm. The retry costs one more message on a
+ * worker that is running anyway.
+ */
+import { CancelledRequestError } from "../../worker/core/errors.js";
+/** What the reader is told when the second ask was dropped as well. */
+export const RISK_DETAIL_DROPPED = 'That explanation was dropped when the run stopped. Close the risk square and open it again.';
+/**
+ * Ask a worker to explain one risk, once more if a cancel dropped the ask.
+ * @param channelOf - Picks the channel to ask on, called again for the retry so it lands on whichever worker is least busy by then.
+ * @param request - The explanation to ask for.
+ * @param mayRetry - Whether asking again can still be answered: false once the pool is terminated, or once its resources are known not to have loaded.
+ * @returns Whatever the worker answered, including its `unavailable`.
+ * @throws {Error} When the ask was dropped and cannot be made again.
+ */
+export async function requestRiskDetail(channelOf, request, mayRetry) {
+    try {
+        return await channelOf().request(request);
+    }
+    catch (error) {
+        if (!(error instanceof CancelledRequestError))
+            throw error;
+        if (!mayRetry())
+            throw new Error(RISK_DETAIL_DROPPED, { cause: error });
+    }
+    return askAgain(channelOf, request);
+}
+async function askAgain(channelOf, request) {
+    try {
+        return await channelOf().request(request);
+    }
+    catch (error) {
+        if (!(error instanceof CancelledRequestError))
+            throw error;
+        throw new Error(RISK_DETAIL_DROPPED, { cause: error });
+    }
+}
+//# sourceMappingURL=riskDetailRequest.js.map

package/lib/osiris/core/riskDetailRequest.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"riskDetailRequest.js","sourceRoot":"","sources":["../../../src/osiris/core/riskDetailRequest.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAEH,OAAO,EAAE,qBAAqB,EAAE,MAAM,6BAA6B,CAAC;AAWpE,uEAAuE;AACvE,MAAM,CAAC,MAAM,mBAAmB,GAC9B,6FAA6F,CAAC;AAEhG;;;;;;;GAOG;AACH,MAAM,CAAC,KAAK,UAAU,iBAAiB,CACrC,SAAwB,EACxB,OAA0B,EAC1B,QAAuB;IAEvB,IAAI,CAAC;QACH,OAAO,MAAM,SAAS,EAAE,CAAC,OAAO,CAAC,OAAO,CAAC,CAAC;IAC5C,CAAC;IAAC,OAAO,KAAK,EAAE,CAAC;QACf,IAAI,CAAC,CAAC,KAAK,YAAY,qBAAqB,CAAC;YAAE,MAAM,KAAK,CAAC;QAC3D,IAAI,CAAC,QAAQ,EAAE;YAAE,MAAM,IAAI,KAAK,CAAC,mBAAmB,EAAE,EAAE,KAAK,EAAE,KAAK,EAAE,CAAC,CAAC;IAC1E,CAAC;IACD,OAAO,QAAQ,CAAC,SAAS,EAAE,OAAO,CAAC,CAAC;AACtC,CAAC;AAED,KAAK,UAAU,QAAQ,CACrB,SAAwB,EACxB,OAA0B;IAE1B,IAAI,CAAC;QACH,OAAO,MAAM,SAAS,EAAE,CAAC,OAAO,CAAC,OAAO,CAAC,CAAC;IAC5C,CAAC;IAAC,OAAO,KAAK,EAAE,CAAC;QACf,IAAI,CAAC,CAAC,KAAK,YAAY,qBAAqB,CAAC;YAAE,MAAM,KAAK,CAAC;QAC3D,MAAM,IAAI,KAAK,CAAC,mBAAmB,EAAE,EAAE,KAAK,EAAE,KAAK,EAAE,CAAC,CAAC;IACzD,CAAC;AACH,CAAC"}

package/lib/osiris/core/riskFindings.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Reading what the toxicity predictor printed.
+ *
+ * `getDetail` answers a flat list of typed strings — 1 is an idCode, 2 is text,
+ * 3 is a number — in which a text line heads the idCodes that follow it. Which
+ * text line it is matters more than anything else the tool shows: "This
+ * molecule is known to be mutagenic" means the compound's own idCode is in a
+ * list derived from RTECS, and the idCode that follows is **the molecule
+ * itself**; "High-risk fragments indicating Mutagenicity" means a substructure
+ * matched, and the idCodes that follow are the substructures.
+ *
+ * Telling them apart is what keeps the red square honest: aspirin, caffeine and
+ * paracetamol all come back high through the first branch, and highlighting the
+ * whole molecule there would call the compound its own toxicophore.
+ */
+import type { DetailEntry, RiskFinding } from './types.ts';
+/**
+ * Turn what the predictor printed into the lines a page shows.
+ *
+ * The matched atoms are left empty here: finding them needs the molecule and
+ * the predictor's own match mode, which `riskDetail` supplies.
+ * @param entries - What `ToxicityPredictor.getDetail` returned.
+ * @returns One finding per sentence, and one per matched fragment.
+ */
+export declare function parseRiskFindings(entries: readonly DetailEntry[]): RiskFinding[];
+//# sourceMappingURL=riskFindings.d.ts.map

package/lib/osiris/core/riskFindings.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"riskFindings.d.ts","sourceRoot":"","sources":["../../../src/osiris/core/riskFindings.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAEH,OAAO,KAAK,EAAE,WAAW,EAAE,WAAW,EAAE,MAAM,YAAY,CAAC;AAO3D;;;;;;;GAOG;AACH,wBAAgB,iBAAiB,CAC/B,OAAO,EAAE,SAAS,WAAW,EAAE,GAC9B,WAAW,EAAE,CAmBf"}

package/lib/osiris/core/riskFindings.js

@@ -0,0 +1,79 @@
+/**
+ * Reading what the toxicity predictor printed.
+ *
+ * `getDetail` answers a flat list of typed strings — 1 is an idCode, 2 is text,
+ * 3 is a number — in which a text line heads the idCodes that follow it. Which
+ * text line it is matters more than anything else the tool shows: "This
+ * molecule is known to be mutagenic" means the compound's own idCode is in a
+ * list derived from RTECS, and the idCode that follows is **the molecule
+ * itself**; "High-risk fragments indicating Mutagenicity" means a substructure
+ * matched, and the idCodes that follow are the substructures.
+ *
+ * Telling them apart is what keeps the red square honest: aspirin, caffeine and
+ * paracetamol all come back high through the first branch, and highlighting the
+ * whole molecule there would call the compound its own toxicophore.
+ */
+/** An idCode, to be drawn as a structure. */
+const ID_CODE = 1;
+/** Plain text. */
+const TEXT = 2;
+/**
+ * Turn what the predictor printed into the lines a page shows.
+ *
+ * The matched atoms are left empty here: finding them needs the molecule and
+ * the predictor's own match mode, which `riskDetail` supplies.
+ * @param entries - What `ToxicityPredictor.getDetail` returned.
+ * @returns One finding per sentence, and one per matched fragment.
+ */
+export function parseRiskFindings(entries) {
+    const findings = [];
+    let heading = { kind: 'note', description: '', severity: null };
+    for (const entry of entries) {
+        if (entry.type === TEXT) {
+            heading = readHeading(entry.value);
+            // A fragment heading says nothing on its own; it is repeated on each of
+            // the fragments that follow it, so the page can draw one row per match.
+            if (heading.kind !== 'fragment')
+                findings.push(line(heading));
+            continue;
+        }
+        if (entry.type !== ID_CODE)
+            continue;
+        // The idCode under a known-molecule heading is the molecule itself.
+        if (heading.kind !== 'fragment')
+            continue;
+        findings.push({ ...line(heading), idCode: entry.value });
+    }
+    return findings;
+}
+function line(heading) {
+    return {
+        kind: heading.kind,
+        description: heading.description,
+        severity: heading.severity,
+        idCode: null,
+        atoms: [],
+        bonds: [],
+    };
+}
+/** `This molecule is known to be mutagenic:` and its three siblings. */
+const KNOWN = /^This molecule is known to be /i;
+const HIGH_RISK = /^High-risk fragments/i;
+const MEDIUM_RISK = /^Medium-risk fragments/i;
+const NOTHING_FOUND = /^No indication for /i;
+function readHeading(value) {
+    if (KNOWN.test(value)) {
+        return { kind: 'known', description: value, severity: null };
+    }
+    if (HIGH_RISK.test(value)) {
+        return { kind: 'fragment', description: value, severity: 'high' };
+    }
+    if (MEDIUM_RISK.test(value)) {
+        return { kind: 'fragment', description: value, severity: 'medium' };
+    }
+    if (NOTHING_FOUND.test(value)) {
+        return { kind: 'none', description: value, severity: null };
+    }
+    return { kind: 'note', description: value, severity: null };
+}
+//# sourceMappingURL=riskFindings.js.map

package/lib/osiris/core/riskFindings.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"riskFindings.js","sourceRoot":"","sources":["../../../src/osiris/core/riskFindings.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAIH,6CAA6C;AAC7C,MAAM,OAAO,GAAG,CAAC,CAAC;AAClB,kBAAkB;AAClB,MAAM,IAAI,GAAG,CAAC,CAAC;AAEf;;;;;;;GAOG;AACH,MAAM,UAAU,iBAAiB,CAC/B,OAA+B;IAE/B,MAAM,QAAQ,GAAkB,EAAE,CAAC;IACnC,IAAI,OAAO,GAAY,EAAE,IAAI,EAAE,MAAM,EAAE,WAAW,EAAE,EAAE,EAAE,QAAQ,EAAE,IAAI,EAAE,CAAC;IAEzE,KAAK,MAAM,KAAK,IAAI,OAAO,EAAE,CAAC;QAC5B,IAAI,KAAK,CAAC,IAAI,KAAK,IAAI,EAAE,CAAC;YACxB,OAAO,GAAG,WAAW,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC;YACnC,wEAAwE;YACxE,wEAAwE;YACxE,IAAI,OAAO,CAAC,IAAI,KAAK,UAAU;gBAAE,QAAQ,CAAC,IAAI,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC,CAAC;YAC9D,SAAS;QACX,CAAC;QACD,IAAI,KAAK,CAAC,IAAI,KAAK,OAAO;YAAE,SAAS;QACrC,oEAAoE;QACpE,IAAI,OAAO,CAAC,IAAI,KAAK,UAAU;YAAE,SAAS;QAC1C,QAAQ,CAAC,IAAI,CAAC,EAAE,GAAG,IAAI,CAAC,OAAO,CAAC,EAAE,MAAM,EAAE,KAAK,CAAC,KAAK,EAAE,CAAC,CAAC;IAC3D,CAAC;IAED,OAAO,QAAQ,CAAC;AAClB,CAAC;AAQD,SAAS,IAAI,CAAC,OAAgB;IAC5B,OAAO;QACL,IAAI,EAAE,OAAO,CAAC,IAAI;QAClB,WAAW,EAAE,OAAO,CAAC,WAAW;QAChC,QAAQ,EAAE,OAAO,CAAC,QAAQ;QAC1B,MAAM,EAAE,IAAI;QACZ,KAAK,EAAE,EAAE;QACT,KAAK,EAAE,EAAE;KACV,CAAC;AACJ,CAAC;AAED,wEAAwE;AACxE,MAAM,KAAK,GAAG,iCAAiC,CAAC;AAChD,MAAM,SAAS,GAAG,uBAAuB,CAAC;AAC1C,MAAM,WAAW,GAAG,yBAAyB,CAAC;AAC9C,MAAM,aAAa,GAAG,sBAAsB,CAAC;AAE7C,SAAS,WAAW,CAAC,KAAa;IAChC,IAAI,KAAK,CAAC,IAAI,CAAC,KAAK,CAAC,EAAE,CAAC;QACtB,OAAO,EAAE,IAAI,EAAE,OAAO,EAAE,WAAW,EAAE,KAAK,EAAE,QAAQ,EAAE,IAAI,EAAE,CAAC;IAC/D,CAAC;IACD,IAAI,SAAS,CAAC,IAAI,CAAC,KAAK,CAAC,EAAE,CAAC;QAC1B,OAAO,EAAE,IAAI,EAAE,UAAU,EAAE,WAAW,EAAE,KAAK,EAAE,QAAQ,EAAE,MAAM,EAAE,CAAC;IACpE,CAAC;IACD,IAAI,WAAW,CAAC,IAAI,CAAC,KAAK,CAAC,EAAE,CAAC;QAC5B,OAAO,EAAE,IAAI,EAAE,UAAU,EAAE,WAAW,EAAE,KAAK,EAAE,QAAQ,EAAE,QAAQ,EAAE,CAAC;IACtE,CAAC;IACD,IAAI,aAAa,CAAC,IAAI,CAAC,KAAK,CAAC,EAAE,CAAC;QAC9B,OAAO,EAAE,IAAI,EAAE,MAAM,EAAE,WAAW,EAAE,KAAK,EAAE,QAAQ,EAAE,IAAI,EAAE,CAAC;IAC9D,CAAC;IACD,OAAO,EAAE,IAAI,EAAE,MAAM,EAAE,WAAW,EAAE,KAAK,EAAE,QAAQ,EAAE,IAAI,EAAE,CAAC;AAC9D,CAAC"}

package/lib/osiris/core/runPredictionJob.d.ts

@@ -0,0 +1,20 @@
+/**
+ * One prediction, wherever it runs.
+ *
+ * The worker serves this, and a page with no `Worker` at all — a unit test,
+ * Node — runs the same function on its own thread. One code path, so what the
+ * tests prove is what the page does.
+ */
+import type { PredictRequest, PredictResponse } from './predictProtocol.ts';
+/**
+ * Answer one job.
+ *
+ * A structure that cannot be read, or that holds no atoms, throws: that is one
+ * bad row, and the run carries on without it. Resources that did not load
+ * return `unavailable` instead, because that is every row and the run must stop.
+ * @param request - The job.
+ * @returns The answer.
+ * @throws {Error} When the molecule itself could not be read or predicted.
+ */
+export declare function runPredictionJob(request: PredictRequest): Promise<PredictResponse>;
+//# sourceMappingURL=runPredictionJob.d.ts.map

package/lib/osiris/core/runPredictionJob.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"runPredictionJob.d.ts","sourceRoot":"","sources":["../../../src/osiris/core/runPredictionJob.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAKH,OAAO,KAAK,EAAE,cAAc,EAAE,eAAe,EAAE,MAAM,sBAAsB,CAAC;AAG5E;;;;;;;;;GASG;AACH,wBAAsB,gBAAgB,CACpC,OAAO,EAAE,cAAc,GACtB,OAAO,CAAC,eAAe,CAAC,CAsB1B"}

package/lib/osiris/core/runPredictionJob.js

@@ -0,0 +1,43 @@
+/**
+ * One prediction, wherever it runs.
+ *
+ * The worker serves this, and a page with no `Worker` at all — a unit test,
+ * Node — runs the same function on its own thread. One code path, so what the
+ * tests prove is what the page does.
+ */
+import { errorMessage } from "../../error/core/toError.js";
+import { predictIdCode, riskDetailOfIdCode } from "./predictIdCode.js";
+import { loadPredictors } from "./predictors.js";
+/**
+ * Answer one job.
+ *
+ * A structure that cannot be read, or that holds no atoms, throws: that is one
+ * bad row, and the run carries on without it. Resources that did not load
+ * return `unavailable` instead, because that is every row and the run must stop.
+ * @param request - The job.
+ * @returns The answer.
+ * @throws {Error} When the molecule itself could not be read or predicted.
+ */
+export async function runPredictionJob(request) {
+    let predictors;
+    try {
+        predictors = await loadPredictors(request.resources);
+    }
+    catch (error) {
+        return { kind: 'unavailable', message: errorMessage(error) };
+    }
+    if (request.kind === 'riskDetail') {
+        return {
+            kind: 'riskDetail',
+            detail: riskDetailOfIdCode(request.idCode, request.risk, predictors),
+        };
+    }
+    return {
+        kind: 'properties',
+        key: request.key,
+        properties: predictIdCode(request.idCode, predictors, {
+            ...(request.label === undefined ? {} : { label: request.label }),
+        }),
+    };
+}
+//# sourceMappingURL=runPredictionJob.js.map

package/lib/osiris/core/runPredictionJob.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"runPredictionJob.js","sourceRoot":"","sources":["../../../src/osiris/core/runPredictionJob.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,EAAE,YAAY,EAAE,MAAM,6BAA6B,CAAC;AAE3D,OAAO,EAAE,aAAa,EAAE,kBAAkB,EAAE,MAAM,oBAAoB,CAAC;AAEvE,OAAO,EAAE,cAAc,EAAE,MAAM,iBAAiB,CAAC;AAEjD;;;;;;;;;GASG;AACH,MAAM,CAAC,KAAK,UAAU,gBAAgB,CACpC,OAAuB;IAEvB,IAAI,UAAU,CAAC;IACf,IAAI,CAAC;QACH,UAAU,GAAG,MAAM,cAAc,CAAC,OAAO,CAAC,SAAS,CAAC,CAAC;IACvD,CAAC;IAAC,OAAO,KAAK,EAAE,CAAC;QACf,OAAO,EAAE,IAAI,EAAE,aAAa,EAAE,OAAO,EAAE,YAAY,CAAC,KAAK,CAAC,EAAE,CAAC;IAC/D,CAAC;IAED,IAAI,OAAO,CAAC,IAAI,KAAK,YAAY,EAAE,CAAC;QAClC,OAAO;YACL,IAAI,EAAE,YAAY;YAClB,MAAM,EAAE,kBAAkB,CAAC,OAAO,CAAC,MAAM,EAAE,OAAO,CAAC,IAAI,EAAE,UAAU,CAAC;SACrE,CAAC;IACJ,CAAC;IAED,OAAO;QACL,IAAI,EAAE,YAAY;QAClB,GAAG,EAAE,OAAO,CAAC,GAAG;QAChB,UAAU,EAAE,aAAa,CAAC,OAAO,CAAC,MAAM,EAAE,UAAU,EAAE;YACpD,GAAG,CAAC,OAAO,CAAC,KAAK,KAAK,SAAS,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,EAAE,KAAK,EAAE,OAAO,CAAC,KAAK,EAAE,CAAC;SACjE,CAAC;KACH,CAAC;AACJ,CAAC"}

package/lib/osiris/core/scales.d.ts

@@ -0,0 +1,70 @@
+/**
+ * The scale every displayed property is read on: how wide the bar is, where
+ * the good band sits, and which published number the labelled mark names.
+ *
+ * Eight of the ten come verbatim from DataWarrior's own `MolecularPropertyHelper.SPEC`
+ * table — the same ranges its own property views draw — so nothing here is a
+ * cut-off picked to look right. The two it has no entry for, drug-likeness and
+ * the drug score, keep the legacy explorer's ranges, and take their fitness
+ * from `DrugScoreCalculator`'s own terms rather than from a new guess.
+ *
+ * The preferred band and the published threshold are different numbers on
+ * purpose: cLogP's band closes at 4, where DataWarrior puts it, while the
+ * published rule of thumb the mark names is 5. The band draws the colour, the
+ * threshold draws the line.
+ */
+import type { PropertyKey } from './propertyKeys.ts';
+/** A published rule of thumb, drawn on the bar as a labelled mark. */
+export interface PropertyThreshold {
+    /** Where on the bar the mark goes. */
+    value: number;
+    /** How it reads, e.g. `≤ 5`. */
+    label: string;
+}
+/** Where a shared scale's numbers come from. */
+export type ScaleSource = 'datawarrior' | 'legacy';
+/** How one property is drawn, ranged and judged. */
+export interface PropertyScale {
+    /** The field of `OsirisProperties` this describes. */
+    key: PropertyKey;
+    /** What the panel and the table column call it. */
+    label: string;
+    /** The unit, empty where the quantity is dimensionless. */
+    unit: string;
+    /** Decimals the value is shown to; `0` for a count. */
+    decimals: number;
+    /** The left end of the bar, and of the plot axis. */
+    rangeMin: number;
+    /** The right end of the bar, and of the plot axis. */
+    rangeMax: number;
+    /** The bottom of the preferred band, or `null` when it has no lower bound. */
+    preferredMin: number | null;
+    /** The top of the preferred band, or `null` when it has no upper bound. */
+    preferredMax: number | null;
+    /**
+     * How far outside the band the fitness takes to fall away. `null` for a
+     * quantity that is already a 0-to-1 fitness.
+     */
+    halfWidth: number | null;
+    /**
+     * Whether a larger number is the better one. `null` where the property has a
+     * band rather than a direction — a molecule wants some stereocentres, not as
+     * many or as few as possible.
+     */
+    higherIsBetter: boolean | null;
+    /** The published rule of thumb to mark, or `null` where there is none. */
+    threshold: PropertyThreshold | null;
+    /** Whether the bar grows from the middle rather than from the left. */
+    diverging: boolean;
+    /** Where the range and the band came from. */
+    source: ScaleSource;
+}
+/** How each displayed property is drawn, ranged and judged. */
+export declare const PROPERTY_SCALES: Record<PropertyKey, PropertyScale>;
+/**
+ * How one property is drawn, ranged and judged.
+ * @param key - Which of the ten.
+ * @returns Its scale.
+ */
+export declare function propertyScale(key: PropertyKey): PropertyScale;
+//# sourceMappingURL=scales.d.ts.map

package/lib/osiris/core/scales.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"scales.d.ts","sourceRoot":"","sources":["../../../src/osiris/core/scales.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAEH,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAErD,sEAAsE;AACtE,MAAM,WAAW,iBAAiB;IAChC,sCAAsC;IACtC,KAAK,EAAE,MAAM,CAAC;IACd,gCAAgC;IAChC,KAAK,EAAE,MAAM,CAAC;CACf;AAED,gDAAgD;AAChD,MAAM,MAAM,WAAW,GAAG,aAAa,GAAG,QAAQ,CAAC;AAEnD,oDAAoD;AACpD,MAAM,WAAW,aAAa;IAC5B,sDAAsD;IACtD,GAAG,EAAE,WAAW,CAAC;IACjB,mDAAmD;IACnD,KAAK,EAAE,MAAM,CAAC;IACd,2DAA2D;IAC3D,IAAI,EAAE,MAAM,CAAC;IACb,uDAAuD;IACvD,QAAQ,EAAE,MAAM,CAAC;IACjB,qDAAqD;IACrD,QAAQ,EAAE,MAAM,CAAC;IACjB,sDAAsD;IACtD,QAAQ,EAAE,MAAM,CAAC;IACjB,8EAA8E;IAC9E,YAAY,EAAE,MAAM,GAAG,IAAI,CAAC;IAC5B,2EAA2E;IAC3E,YAAY,EAAE,MAAM,GAAG,IAAI,CAAC;IAC5B;;;OAGG;IACH,SAAS,EAAE,MAAM,GAAG,IAAI,CAAC;IACzB;;;;OAIG;IACH,cAAc,EAAE,OAAO,GAAG,IAAI,CAAC;IAC/B,0EAA0E;IAC1E,SAAS,EAAE,iBAAiB,GAAG,IAAI,CAAC;IACpC,uEAAuE;IACvE,SAAS,EAAE,OAAO,CAAC;IACnB,8CAA8C;IAC9C,MAAM,EAAE,WAAW,CAAC;CACrB;AAED,+DAA+D;AAC/D,eAAO,MAAM,eAAe,EAAE,MAAM,CAAC,WAAW,EAAE,aAAa,CA+J9D,CAAC;AAEF;;;;GAIG;AACH,wBAAgB,aAAa,CAAC,GAAG,EAAE,WAAW,GAAG,aAAa,CAE7D"}

package/lib/osiris/core/scales.js

@@ -0,0 +1,185 @@
+/**
+ * The scale every displayed property is read on: how wide the bar is, where
+ * the good band sits, and which published number the labelled mark names.
+ *
+ * Eight of the ten come verbatim from DataWarrior's own `MolecularPropertyHelper.SPEC`
+ * table — the same ranges its own property views draw — so nothing here is a
+ * cut-off picked to look right. The two it has no entry for, drug-likeness and
+ * the drug score, keep the legacy explorer's ranges, and take their fitness
+ * from `DrugScoreCalculator`'s own terms rather than from a new guess.
+ *
+ * The preferred band and the published threshold are different numbers on
+ * purpose: cLogP's band closes at 4, where DataWarrior puts it, while the
+ * published rule of thumb the mark names is 5. The band draws the colour, the
+ * threshold draws the line.
+ */
+/** How each displayed property is drawn, ranged and judged. */
+export const PROPERTY_SCALES = {
+    logP: {
+        key: 'logP',
+        label: 'cLogP',
+        unit: '',
+        decimals: 2,
+        rangeMin: 0,
+        rangeMax: 8,
+        preferredMin: null,
+        preferredMax: 4,
+        halfWidth: 0.5,
+        higherIsBetter: false,
+        threshold: { value: 5, label: '≤ 5' },
+        diverging: false,
+        source: 'datawarrior',
+    },
+    logS: {
+        key: 'logS',
+        label: 'Solubility',
+        unit: 'log(mol/L)',
+        decimals: 2,
+        rangeMin: -8,
+        rangeMax: 2,
+        preferredMin: -4,
+        preferredMax: null,
+        halfWidth: 0.5,
+        higherIsBetter: true,
+        threshold: { value: -4, label: '> −4' },
+        diverging: false,
+        source: 'datawarrior',
+    },
+    molecularWeight: {
+        key: 'molecularWeight',
+        label: 'Molweight',
+        unit: 'g/mol',
+        decimals: 2,
+        rangeMin: 0,
+        rangeMax: 800,
+        preferredMin: null,
+        preferredMax: 400,
+        halfWidth: 50,
+        higherIsBetter: false,
+        threshold: { value: 450, label: '< 450' },
+        diverging: false,
+        source: 'datawarrior',
+    },
+    polarSurfaceArea: {
+        key: 'polarSurfaceArea',
+        label: 'TPSA',
+        unit: 'Ų',
+        decimals: 2,
+        rangeMin: 0,
+        rangeMax: 250,
+        preferredMin: null,
+        preferredMax: 120,
+        halfWidth: 20,
+        higherIsBetter: false,
+        threshold: null,
+        diverging: false,
+        source: 'datawarrior',
+    },
+    druglikeness: {
+        key: 'druglikeness',
+        label: 'Druglikeness',
+        unit: '',
+        decimals: 2,
+        rangeMin: -10,
+        rangeMax: 10,
+        preferredMin: 0,
+        preferredMax: null,
+        // `DrugScoreCalculator` scores drug-likeness as 1/(1+e^-d), which is this
+        // same valuation with a lower bound of 0 and a half-width of 1. So the
+        // ramp behind the bar is the library's own term, not a second opinion.
+        halfWidth: 1,
+        higherIsBetter: true,
+        threshold: { value: 0, label: '> 0' },
+        diverging: true,
+        source: 'legacy',
+    },
+    acceptorCount: {
+        key: 'acceptorCount',
+        label: 'H-bond acceptors',
+        unit: '',
+        decimals: 0,
+        rangeMin: 0,
+        rangeMax: 16,
+        preferredMin: null,
+        preferredMax: 10,
+        halfWidth: 1,
+        higherIsBetter: false,
+        threshold: null,
+        diverging: false,
+        source: 'datawarrior',
+    },
+    donorCount: {
+        key: 'donorCount',
+        label: 'H-bond donors',
+        unit: '',
+        decimals: 0,
+        rangeMin: 0,
+        rangeMax: 8,
+        preferredMin: null,
+        preferredMax: 5,
+        halfWidth: 0.5,
+        higherIsBetter: false,
+        threshold: null,
+        diverging: false,
+        source: 'datawarrior',
+    },
+    stereoCenterCount: {
+        key: 'stereoCenterCount',
+        label: 'Stereocentres',
+        unit: '',
+        decimals: 0,
+        rangeMin: 0,
+        rangeMax: 8,
+        preferredMin: 1,
+        preferredMax: 3,
+        halfWidth: 2,
+        higherIsBetter: null,
+        threshold: null,
+        diverging: false,
+        source: 'datawarrior',
+    },
+    rotatableBondCount: {
+        key: 'rotatableBondCount',
+        label: 'Rotatable bonds',
+        unit: '',
+        decimals: 0,
+        rangeMin: 0,
+        rangeMax: 20,
+        preferredMin: null,
+        preferredMax: 4,
+        halfWidth: 5,
+        higherIsBetter: false,
+        threshold: null,
+        diverging: false,
+        source: 'datawarrior',
+    },
+    drugScore: {
+        key: 'drugScore',
+        label: 'Drug score',
+        unit: '',
+        decimals: 2,
+        // The legacy bar, kept: it grows from the middle and runs -1 to 1, so a
+        // score always sits in its right half. The quantity itself is a product of
+        // terms in (0.5, 1) and four risk factors, so it cannot leave (0, 1).
+        rangeMin: -1,
+        rangeMax: 1,
+        preferredMin: null,
+        preferredMax: null,
+        // Already a 0-to-1 fitness: it is the product of the four valuations
+        // `DrugScoreCalculator` computes, so valuing it again would square it.
+        halfWidth: null,
+        higherIsBetter: true,
+        threshold: null,
+        diverging: true,
+        source: 'legacy',
+    },
+};
+/**
+ * How one property is drawn, ranged and judged.
+ * @param key - Which of the ten.
+ * @returns Its scale.
+ */
+export function propertyScale(key) {
+    return PROPERTY_SCALES[key];
+}
+//# sourceMappingURL=scales.js.map

package/lib/osiris/core/scales.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"scales.js","sourceRoot":"","sources":["../../../src/osiris/core/scales.ts"],"names":[],"mappings":"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"}

package/lib/osiris/core/types.d.ts

@@ -0,0 +1,91 @@
+/**
+ * What the tool predicts about one molecule, and how a risk is explained.
+ *
+ * Every quantity OpenChemLib can fail to compute is `number | null` here, never
+ * the library's own sentinel: cLogP and solubility answer `-999`, the polar
+ * surface area `-1`, drug-likeness `-999` when the tables did not load and `-1`
+ * when no fragment matched, and a risk `0`. None of them is `NaN`, and
+ * `DrugScoreCalculator` consumes every one of them and returns a plausible
+ * number, so a sentinel that leaves this module is a wrong value on screen with
+ * nothing to say it is wrong.
+ */
+/** The four risks OSIRIS assesses, in the order the library numbers them. */
+export declare const RISK_TYPES: readonly ["mutagenic", "tumorigenic", "irritant", "reproductive"];
+/** One of the four risks. */
+export type RiskType = (typeof RISK_TYPES)[number];
+/**
+ * How risky one type came back.
+ *
+ * `unknown` is the library's `RISK_UNKNOWN`, which it returns when its fragment
+ * tables did not load — never "nothing was found", which is `none`.
+ */
+export type RiskLevel = 'unknown' | 'none' | 'low' | 'high';
+/** Everything the tool shows for one molecule. */
+export interface OsirisProperties {
+    /** The canonical idCode, read before anything touched the molecule. */
+    idCode: string;
+    /** The canonical SMILES, for a link and for a download. */
+    smiles: string;
+    /** A name from the source, or the SMILES when it carried none. */
+    label: string;
+    /** e.g. `C6H6`. */
+    molecularFormula: string;
+    /** The relative molecular weight in g/mol — 78.11 for benzene, never the monoisotopic mass. */
+    molecularWeight: number;
+    /** cLogP, the octanol/water partition coefficient. */
+    logP: number | null;
+    /** Aqueous solubility, log10 of mol/L at 25 °C and pH 7.5. */
+    logS: number | null;
+    /** Topological polar surface area, in Ų. */
+    polarSurfaceArea: number | null;
+    /** Drug-likeness: positive is drug-like, negative is not. */
+    druglikeness: number | null;
+    /** The drug score, 0 to 1. `null` whenever any of its inputs was unknown. */
+    drugScore: number | null;
+    /** Every nitrogen and oxygen — the OSIRIS definition, not Lipinski's. */
+    acceptorCount: number;
+    /** Every nitrogen and oxygen carrying at least one hydrogen. */
+    donorCount: number;
+    /** Atoms with a real, non-pseudo parity. */
+    stereoCenterCount: number;
+    /** Single, non-ring, non-terminal, non-amide bonds. */
+    rotatableBondCount: number;
+    /** How the four risks came back. */
+    risks: Record<RiskType, RiskLevel>;
+}
+/** Which branch of the predictor produced one line of a risk explanation. */
+export type RiskFindingKind = 'known' | 'fragment' | 'none' | 'note';
+/** One line of why a risk came back as it did. */
+export interface RiskFinding {
+    /**
+     * `known` — the molecule's own idCode is in the RTECS-derived list, so there
+     * is nothing to highlight. `fragment` — an alerting substructure matched.
+     * `none` — nothing was found. `note` — anything else the predictor printed.
+     */
+    kind: RiskFindingKind;
+    /** The sentence the predictor printed, verbatim. */
+    description: string;
+    /** How alerting the matched fragment is, or `null` when this is not a fragment. */
+    severity: 'high' | 'medium' | null;
+    /** The fragment's idCode, or `null` — a known molecule carries no fragment. */
+    idCode: string | null;
+    /** The molecule's atoms the fragment matched, so the page can highlight them. */
+    atoms: readonly number[];
+    /** The molecule's bonds the fragment matched. */
+    bonds: readonly number[];
+}
+/** Why one risk came back as it did. */
+export interface RiskDetail {
+    /** Which of the four risks this explains. */
+    risk: RiskType;
+    /** What the predictor printed, one entry per sentence or matched fragment. */
+    findings: readonly RiskFinding[];
+}
+/** One entry of a `ParameterizedString[]`, as OpenChemLib hands it over. */
+export interface DetailEntry {
+    /** 1 is an idCode, 2 is text, 3 is a number written out. */
+    type: number;
+    /** The entry itself. */
+    value: string;
+}
+//# sourceMappingURL=types.d.ts.map

package/lib/osiris/core/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../src/osiris/core/types.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,6EAA6E;AAC7E,eAAO,MAAM,UAAU,mEAKb,CAAC;AAEX,6BAA6B;AAC7B,MAAM,MAAM,QAAQ,GAAG,CAAC,OAAO,UAAU,CAAC,CAAC,MAAM,CAAC,CAAC;AAEnD;;;;;GAKG;AACH,MAAM,MAAM,SAAS,GAAG,SAAS,GAAG,MAAM,GAAG,KAAK,GAAG,MAAM,CAAC;AAE5D,kDAAkD;AAClD,MAAM,WAAW,gBAAgB;IAC/B,uEAAuE;IACvE,MAAM,EAAE,MAAM,CAAC;IACf,2DAA2D;IAC3D,MAAM,EAAE,MAAM,CAAC;IACf,kEAAkE;IAClE,KAAK,EAAE,MAAM,CAAC;IACd,mBAAmB;IACnB,gBAAgB,EAAE,MAAM,CAAC;IACzB,+FAA+F;IAC/F,eAAe,EAAE,MAAM,CAAC;IACxB,sDAAsD;IACtD,IAAI,EAAE,MAAM,GAAG,IAAI,CAAC;IACpB,8DAA8D;IAC9D,IAAI,EAAE,MAAM,GAAG,IAAI,CAAC;IACpB,6CAA6C;IAC7C,gBAAgB,EAAE,MAAM,GAAG,IAAI,CAAC;IAChC,6DAA6D;IAC7D,YAAY,EAAE,MAAM,GAAG,IAAI,CAAC;IAC5B,6EAA6E;IAC7E,SAAS,EAAE,MAAM,GAAG,IAAI,CAAC;IACzB,yEAAyE;IACzE,aAAa,EAAE,MAAM,CAAC;IACtB,gEAAgE;IAChE,UAAU,EAAE,MAAM,CAAC;IACnB,4CAA4C;IAC5C,iBAAiB,EAAE,MAAM,CAAC;IAC1B,uDAAuD;IACvD,kBAAkB,EAAE,MAAM,CAAC;IAC3B,oCAAoC;IACpC,KAAK,EAAE,MAAM,CAAC,QAAQ,EAAE,SAAS,CAAC,CAAC;CACpC;AAED,6EAA6E;AAC7E,MAAM,MAAM,eAAe,GAAG,OAAO,GAAG,UAAU,GAAG,MAAM,GAAG,MAAM,CAAC;AAErE,kDAAkD;AAClD,MAAM,WAAW,WAAW;IAC1B;;;;OAIG;IACH,IAAI,EAAE,eAAe,CAAC;IACtB,oDAAoD;IACpD,WAAW,EAAE,MAAM,CAAC;IACpB,mFAAmF;IACnF,QAAQ,EAAE,MAAM,GAAG,QAAQ,GAAG,IAAI,CAAC;IACnC,+EAA+E;IAC/E,MAAM,EAAE,MAAM,GAAG,IAAI,CAAC;IACtB,iFAAiF;IACjF,KAAK,EAAE,SAAS,MAAM,EAAE,CAAC;IACzB,iDAAiD;IACjD,KAAK,EAAE,SAAS,MAAM,EAAE,CAAC;CAC1B;AAED,wCAAwC;AACxC,MAAM,WAAW,UAAU;IACzB,6CAA6C;IAC7C,IAAI,EAAE,QAAQ,CAAC;IACf,8EAA8E;IAC9E,QAAQ,EAAE,SAAS,WAAW,EAAE,CAAC;CAClC;AAED,4EAA4E;AAC5E,MAAM,WAAW,WAAW;IAC1B,4DAA4D;IAC5D,IAAI,EAAE,MAAM,CAAC;IACb,wBAAwB;IACxB,KAAK,EAAE,MAAM,CAAC;CACf"}

package/lib/osiris/core/types.js

@@ -0,0 +1,19 @@
+/**
+ * What the tool predicts about one molecule, and how a risk is explained.
+ *
+ * Every quantity OpenChemLib can fail to compute is `number | null` here, never
+ * the library's own sentinel: cLogP and solubility answer `-999`, the polar
+ * surface area `-1`, drug-likeness `-999` when the tables did not load and `-1`
+ * when no fragment matched, and a risk `0`. None of them is `NaN`, and
+ * `DrugScoreCalculator` consumes every one of them and returns a plausible
+ * number, so a sentinel that leaves this module is a wrong value on screen with
+ * nothing to say it is wrong.
+ */
+/** The four risks OSIRIS assesses, in the order the library numbers them. */
+export const RISK_TYPES = [
+    'mutagenic',
+    'tumorigenic',
+    'irritant',
+    'reproductive',
+];
+//# sourceMappingURL=types.js.map

package/lib/osiris/core/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../../../src/osiris/core/types.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,6EAA6E;AAC7E,MAAM,CAAC,MAAM,UAAU,GAAG;IACxB,WAAW;IACX,aAAa;IACb,UAAU;IACV,cAAc;CACN,CAAC"}