react-cheminfo 0.51.0 → 0.52.0

package/README.md

@@ -30,22 +30,24 @@ would mean two Blueprint style trees in one page.
 Subpaths are **bundle boundaries, not taxonomy**: a feature gets its own door
 only when it drags a heavy dependency behind it.
 
-| Import                             | Holds                                             | Costs                                            |
-| ---------------------------------- | ------------------------------------------------- | ------------------------------------------------ |
-| `react-cheminfo/core`              | every framework-free helper — 140 value exports   | nothing                                          |
-| `react-cheminfo/ui`                | every React component and hook — 60 value exports | React                                            |
-| `react-cheminfo/vite`              | the prerender plugin and the OG card              | nothing; React on the card                       |
-| `react-cheminfo/pages`             | the Cloudflare Pages analytics middleware         | nothing                                          |
-| `react-cheminfo/orbital`           | the 3D atomic-orbital viewer                      | React, molstar                                   |
-| `react-cheminfo/molecule3d`        | the 3D molecule viewer and its toolbar            | React, molstar                                   |
-| `react-cheminfo/structure`         | the structure editor and renderer                 | React, react-ocl, OCL                            |
-| `react-cheminfo/conformers`        | conformer generation, ranking and refinement      | OCL                                              |
-| `react-cheminfo/slides`            | the deck format and the slideshow player          | React, react-markdown                            |
-| `react-cheminfo/spectra`           | the spectra processing settings editors           | React; types only from spectra-processor, ml-pca |
-| `react-cheminfo/ir`                | the infrared chart, band table and editor         | React, ir-spectrum, convert-to-jcamp             |
-| `react-cheminfo/xtb`               | GFN2-xTB as a geometry relaxer                    | nothing on import; xtb-wasm on the first call    |
-| `react-cheminfo/styles/chrome.css` | the shared tokens and site-header stylesheet      | nothing                                          |
-| `react-cheminfo/styles/slides.css` | the deck stylesheet, themed on the site's colours | nothing                                          |
+| Import                             | Holds                                                 | Costs                                            |
+| ---------------------------------- | ----------------------------------------------------- | ------------------------------------------------ |
+| `react-cheminfo/core`              | every framework-free helper — 140 value exports       | nothing                                          |
+| `react-cheminfo/ui`                | every React component and hook — 60 value exports     | React                                            |
+| `react-cheminfo/vite`              | the prerender plugin and the OG card                  | nothing; React on the card                       |
+| `react-cheminfo/pages`             | the Cloudflare Pages analytics middleware             | nothing                                          |
+| `react-cheminfo/orbital`           | the 3D atomic-orbital viewer                          | React, molstar                                   |
+| `react-cheminfo/molecule3d`        | the 3D molecule viewer and its toolbar                | React, molstar                                   |
+| `react-cheminfo/structure`         | the structure editor and renderer                     | React, react-ocl, OCL                            |
+| `react-cheminfo/conformers`        | conformer generation, ranking and refinement          | OCL                                              |
+| `react-cheminfo/slides`            | the deck format and the slideshow player              | React, react-markdown                            |
+| `react-cheminfo/spectra`           | the spectra processing settings editors               | React; types only from spectra-processor, ml-pca |
+| `react-cheminfo/ir`                | the infrared chart, band table and editor             | React, ir-spectrum, convert-to-jcamp             |
+| `react-cheminfo/xtb`               | GFN2-xTB as a geometry relaxer                        | nothing on import; xtb-wasm on the first call    |
+| `react-cheminfo/host`              | data handed over by a page that frames the tool       | nothing on import; ajv once the page is framed   |
+| `react-cheminfo/host-testing`      | a stand-in host and SciPeaks' messages, for e2e tests | nothing; Node only                               |
+| `react-cheminfo/styles/chrome.css` | the shared tokens and site-header stylesheet          | nothing                                          |
+| `react-cheminfo/styles/slides.css` | the deck stylesheet, themed on the site's colours     | nothing                                          |
 
 A backend serving an RIS endpoint, a prerender script writing a sitemap, and
 every unit test of that logic therefore load no React at all — and a worker
@@ -116,6 +118,7 @@ through a wildcard subpath exactly as `react-science` serves its own.
 | **Parallel coordinates**   | `parallelAxisOf`, `parallelAxisLayouts`, `parallelIncludedMask`, `parallelKeptCount`, `parallelNearestRow`, `parallelSegmentAt`, `parallelBandAt`, `parallelRangeOf`, `parallelPalette`, `parallelColorSteps`, `paintParallelLines`                                        | `ParallelCoordinates`                                                                                                                                                                                                                                                                               |
 | **Periodic table**         | `PERIODIC_ELEMENTS`, `elementBySymbol`, `elementByAtomicNumber`, `cellOf`, `placedElements`, `elementByArrowKey`, `EMPTY_BLOCK`, `categorySwatch`, `CATEGORY_LABELS`                                                                                                       | `PeriodicTable`, `ElementCell`, `CategoryLegend`                                                                                                                                                                                                                                                    |
 | **Taxonomy**               | `TAXON_RANKS`, `PRINCIPAL_RANKS`, `rankOrder`, `isPrincipalRank`, `isGenusOrBelow`, `isAboveGenus`, `principalLineage`, `lineageFromNodes`, `lineageFromRanks`, `genusOrBelow`, `ncbiTaxonomyUrl`, `splitOrganismName`                                                     | `TaxonLineage`, `OrganismName`, `useRankLabel`                                                                                                                                                                                                                                                      |
+| **Framed by a host**       | `hostStructureLoader`, `readHostMolecule`, `STRUCTURE_KINDS`, `connectHost`, `selectInputs`, `checkValue`, `kindAccepts`, `parseRequest` (all `/host`); `startStandInHost`, `SCIPEAKS_ETHYLBENZENE_LOAD` (`/host-testing`)                                                 | `useHostConnection` (`/host`)                                                                                                                                                                                                                                                                       |
 
 Everything in that table is exported from `./core`, `./ui`, `./slides`,
 `./vite` or `./structure` and nothing else is: the sub-components a component is built
@@ -836,6 +839,58 @@ const included = useMemo(
   subject — a formula through `react-mf`, a structure, a name — and a readout of
   strings cannot hold any of that.
 
+## Framed by a notebook
+
+A page that frames a tool — an electronic lab notebook such as SciPeaks, a
+course — can hand it typed data instead of writing it into the link. The tool
+says `cheminfo:hello` to its parent, the parent answers `cheminfo:connect` with
+a private `MessageChannel` port, and the data arrives on that port as
+`{ kind, value }` items, each checked against pipeline.cheminfo.org's JSON
+Schema before the tool reads it. A tool taking a structure writes two things:
+
+```ts
+// src/tool.ts
+import type { ToolInterface } from 'react-cheminfo/host';
+import { STRUCTURE_KINDS, hostStructureLoader } from 'react-cheminfo/host';
+
+export const TOOL: ToolInterface = {
+  name: '3d',
+  inputs: [{ key: 'structure', kinds: STRUCTURE_KINDS }],
+  outputs: [],
+};
+
+export const loadFromHost = hostStructureLoader((molecule, label) => {
+  loadSmiles(molecule.toIsomericSmiles(), label);
+});
+```
+
+```tsx
+// App.tsx, right after the hook that applies the address
+useHostConnection(TOOL, { load: loadFromHost, build: BUILD_INFO });
+```
+
+- **Nothing is downloaded unless the page is framed**: the connection and ajv
+  are one lazy chunk, fetched once a parent or an opener exists.
+- **A structure that does not read is answered, not shown**: the host gets
+  `unreadable` with one sentence it can display, and the screen does not change.
+  A molfile whose atoms all sit on one point — SciPeaks stores some that way —
+  is laid out again.
+- **The same document twice is applied once**, so a host re-sending a sample
+  never overwrites what the visitor did with it.
+
+`react-cheminfo/host-testing` serves a stand-in host for Playwright on
+`127.0.0.1`, and exports `SCIPEAKS_ETHYLBENZENE_LOAD`: the message SciPeaks'
+tool tab sends for a sample, byte for byte. visualizer-helper's tests pin the
+same message, so a change on either side fails a test rather than a notebook.
+
+```ts
+const host = await startStandInHost();
+await page.goto(
+  host.pageUrl(`${origin}/?embed=1`, [SCIPEAKS_ETHYLBENZENE_LOAD]),
+);
+const { results } = await page.evaluate(readStandInHostLog);
+```
+
 ## Speaking four languages
 
 Every word this library puts on a page — the header, the Tools menu, the Cite

package/lib/host/core/connectHost.d.ts

@@ -0,0 +1,75 @@
+/**
+ * A tool's side of the host protocol: introduce itself to the page that
+ * frames it, take the private port that page answers with, and serve what
+ * arrives through it.
+ *
+ * Free of React and of the DOM — the window is handed in — so a test drives the
+ * whole exchange with a fake host and a real `MessageChannel`.
+ */
+import type { CheckedValue } from './kinds.ts';
+import type { HostError, HostItem, ToolInterface } from './protocol.ts';
+/** The item an input took, and its value as the input's kind reads it. */
+export interface LoadedInput {
+    key: string;
+    item: HostItem;
+    checked: CheckedValue;
+}
+/** What a window `message` event carries, as far as the protocol reads it. */
+export interface HostMessageEvent {
+    data: unknown;
+    source: unknown;
+    ports: readonly MessagePort[];
+}
+/** Where the connection runs, and what it serves. */
+export interface HostConnectionOptions {
+    /** The page to introduce the tool to: the parent frame, or the opener. */
+    host: {
+        postMessage: (message: unknown, targetOrigin: string) => void;
+    };
+    /** Subscribe to this window's messages; the returned function unsubscribes. */
+    listen: (listener: (event: HostMessageEvent) => void) => () => void;
+    /** What the tool takes and gives, as `hello` announces it. */
+    tool: ToolInterface;
+    /** The tool's origin, as `hello` states it. */
+    origin: string;
+    /** The build that is running, as the About states it, or `null`. */
+    build: unknown;
+    /**
+     * Show the inputs of a new document. Throwing means they could not be read:
+     * the error's message goes back to the host, and the document is not marked
+     * as applied.
+     */
+    load: (inputs: readonly LoadedInput[]) => void;
+}
+/** What choosing the items of a request gave. */
+export type InputSelection = {
+    ok: true;
+    inputs: LoadedInput[];
+} | {
+    ok: false;
+    error: HostError;
+};
+/**
+ * Say `hello` to the host, and serve its requests once it connects.
+ *
+ * A `connect` is accepted only from the window `hello` went to, and a second
+ * one replaces the first — a host that reloads its own script connects again.
+ * A document is applied once: the same one again is answered as before and
+ * changes nothing, so a host re-sending it never overwrites the user's work.
+ * @param options - The window, the tool, and its load function.
+ * @returns The function that stops listening and closes the port.
+ */
+export declare function connectHost(options: HostConnectionOptions): () => void;
+/**
+ * Give each input of the tool one item of a request.
+ *
+ * Each input tries its kinds in its own order of preference, and takes the
+ * first item that falls under one and passes that kind's schema: the tool
+ * knows which notation serves it best, whatever order the host listed them in.
+ * An item naming another input's `key` is left to that input.
+ * @param tool - What the tool takes.
+ * @param items - What the host sent.
+ * @returns One item per input, or why an input got none.
+ */
+export declare function selectInputs(tool: ToolInterface, items: readonly HostItem[]): InputSelection;
+//# sourceMappingURL=connectHost.d.ts.map

package/lib/host/core/connectHost.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"connectHost.d.ts","sourceRoot":"","sources":["../../../src/host/core/connectHost.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,KAAK,EAAE,YAAY,EAAa,MAAM,YAAY,CAAC;AAE1D,OAAO,KAAK,EAGV,SAAS,EACT,QAAQ,EAIR,aAAa,EAEd,MAAM,eAAe,CAAC;AAQvB,0EAA0E;AAC1E,MAAM,WAAW,WAAW;IAC1B,GAAG,EAAE,MAAM,CAAC;IACZ,IAAI,EAAE,QAAQ,CAAC;IACf,OAAO,EAAE,YAAY,CAAC;CACvB;AAED,8EAA8E;AAC9E,MAAM,WAAW,gBAAgB;IAC/B,IAAI,EAAE,OAAO,CAAC;IACd,MAAM,EAAE,OAAO,CAAC;IAChB,KAAK,EAAE,SAAS,WAAW,EAAE,CAAC;CAC/B;AAED,qDAAqD;AACrD,MAAM,WAAW,qBAAqB;IACpC,0EAA0E;IAC1E,IAAI,EAAE;QAAE,WAAW,EAAE,CAAC,OAAO,EAAE,OAAO,EAAE,YAAY,EAAE,MAAM,KAAK,IAAI,CAAA;KAAE,CAAC;IACxE,+EAA+E;IAC/E,MAAM,EAAE,CAAC,QAAQ,EAAE,CAAC,KAAK,EAAE,gBAAgB,KAAK,IAAI,KAAK,MAAM,IAAI,CAAC;IACpE,8DAA8D;IAC9D,IAAI,EAAE,aAAa,CAAC;IACpB,+CAA+C;IAC/C,MAAM,EAAE,MAAM,CAAC;IACf,oEAAoE;IACpE,KAAK,EAAE,OAAO,CAAC;IACf;;;;OAIG;IACH,IAAI,EAAE,CAAC,MAAM,EAAE,SAAS,WAAW,EAAE,KAAK,IAAI,CAAC;CAChD;AAED,iDAAiD;AACjD,MAAM,MAAM,cAAc,GACxB;IAAE,EAAE,EAAE,IAAI,CAAC;IAAC,MAAM,EAAE,WAAW,EAAE,CAAA;CAAE,GAAG;IAAE,EAAE,EAAE,KAAK,CAAC;IAAC,KAAK,EAAE,SAAS,CAAA;CAAE,CAAC;AAExE;;;;;;;;;GASG;AACH,wBAAgB,WAAW,CAAC,OAAO,EAAE,qBAAqB,GAAG,MAAM,IAAI,CA0EtE;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,YAAY,CAC1B,IAAI,EAAE,aAAa,EACnB,KAAK,EAAE,SAAS,QAAQ,EAAE,GACzB,cAAc,CA4BhB"}

package/lib/host/core/connectHost.js

@@ -0,0 +1,171 @@
+/**
+ * A tool's side of the host protocol: introduce itself to the page that
+ * frames it, take the private port that page answers with, and serve what
+ * arrives through it.
+ *
+ * Free of React and of the DOM — the window is handed in — so a test drives the
+ * whole exchange with a fake host and a real `MessageChannel`.
+ */
+import { checkValue, isKnownKind, kindAccepts } from "./kinds.js";
+import { HELLO_TYPE, PROTOCOL_VERSION, isConnect, parseRequest, } from "./protocol.js";
+/**
+ * Say `hello` to the host, and serve its requests once it connects.
+ *
+ * A `connect` is accepted only from the window `hello` went to, and a second
+ * one replaces the first — a host that reloads its own script connects again.
+ * A document is applied once: the same one again is answered as before and
+ * changes nothing, so a host re-sending it never overwrites the user's work.
+ * @param options - The window, the tool, and its load function.
+ * @returns The function that stops listening and closes the port.
+ */
+export function connectHost(options) {
+    const { host, listen, tool, origin, build, load } = options;
+    let port = null;
+    let appliedDocument = null;
+    let appliedUsed = [];
+    function serve(data) {
+        const request = parseRequest(data);
+        if (request === null)
+            return;
+        const result = request.type === 'load' ? applyLoad(request) : answerGet(request, tool);
+        port?.postMessage(result);
+    }
+    function applyLoad(request) {
+        const { id, document, items } = request;
+        if (document === appliedDocument) {
+            return { type: 'result', id, ok: true, used: appliedUsed };
+        }
+        const selection = selectInputs(tool, items);
+        if (!selection.ok) {
+            return { type: 'result', id, ok: false, error: selection.error };
+        }
+        try {
+            load(selection.inputs);
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            return {
+                type: 'result',
+                id,
+                ok: false,
+                error: { code: 'unreadable', message },
+            };
+        }
+        appliedDocument = document;
+        appliedUsed = selection.inputs.map(({ key, item }) => ({
+            key,
+            kind: item.kind,
+        }));
+        return { type: 'result', id, ok: true, used: appliedUsed };
+    }
+    const stopListening = listen((event) => {
+        if (event.source !== host || !isConnect(event.data))
+            return;
+        const received = event.ports[0];
+        if (received === undefined)
+            return;
+        port?.close();
+        port = received;
+        port.addEventListener('message', (message) => {
+            serve(message.data);
+        });
+        port.start();
+    });
+    const hello = {
+        type: HELLO_TYPE,
+        version: PROTOCOL_VERSION,
+        tool: {
+            name: tool.name,
+            origin,
+            build,
+            inputs: tool.inputs,
+            outputs: tool.outputs,
+        },
+    };
+    // `hello` says nothing a stranger may not read, and the parent's origin is
+    // not knowable until it answers.
+    host.postMessage(hello, '*');
+    return () => {
+        stopListening();
+        port?.close();
+        port = null;
+    };
+}
+/**
+ * Give each input of the tool one item of a request.
+ *
+ * Each input tries its kinds in its own order of preference, and takes the
+ * first item that falls under one and passes that kind's schema: the tool
+ * knows which notation serves it best, whatever order the host listed them in.
+ * An item naming another input's `key` is left to that input.
+ * @param tool - What the tool takes.
+ * @param items - What the host sent.
+ * @returns One item per input, or why an input got none.
+ */
+export function selectInputs(tool, items) {
+    const inputs = [];
+    for (const input of tool.inputs) {
+        const errors = [];
+        const loaded = selectInput(input, items, errors);
+        if (loaded !== null) {
+            inputs.push(loaded);
+            continue;
+        }
+        if (errors.length > 0) {
+            return {
+                ok: false,
+                error: {
+                    code: 'invalid',
+                    message: `No item for ${input.key} has the shape its kind requires, so ${tool.name} loaded nothing.`,
+                    errors,
+                },
+            };
+        }
+        return {
+            ok: false,
+            error: {
+                code: 'no-input',
+                message: `No item is a ${KIND_LIST.format(input.kinds)}, so ${tool.name} loaded nothing.`,
+            },
+        };
+    }
+    return { ok: true, inputs };
+}
+function selectInput(input, items, errors) {
+    for (const accepted of input.kinds) {
+        if (!isKnownKind(accepted))
+            continue;
+        for (const item of items) {
+            if (item.key !== undefined && item.key !== input.key)
+                continue;
+            if (!kindAccepts(accepted, item.kind))
+                continue;
+            const loaded = checkItem(input.key, accepted, item, errors);
+            if (loaded !== null)
+                return loaded;
+        }
+    }
+    return null;
+}
+function checkItem(key, accepted, item, errors) {
+    const outcome = checkValue(accepted, item.value);
+    if (outcome.valid)
+        return { key, item, checked: outcome.checked };
+    for (const error of outcome.errors)
+        errors.push(`${item.kind} ${error}`);
+    return null;
+}
+function answerGet(request, tool) {
+    // Nothing goes back yet: no tool declares an output.
+    return {
+        type: 'result',
+        id: request.id,
+        ok: false,
+        error: {
+            code: 'no-output',
+            message: `${tool.name} has nothing to give back yet.`,
+        },
+    };
+}
+const KIND_LIST = new Intl.ListFormat('en', { type: 'disjunction' });
+//# sourceMappingURL=connectHost.js.map

package/lib/host/core/connectHost.js.map

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

package/lib/host/core/hostStructure.d.ts

@@ -0,0 +1,52 @@
+/**
+ * A structure a host handed over, read into the molecule a tool works on.
+ *
+ * Every tool of the family that takes a structure takes it the same way — in
+ * the three notations a notebook keeps, the one that says the most first — so
+ * the kinds, the parsing and the sentence a host reads when it fails are
+ * written once, here.
+ */
+import type { Molecule } from 'openchemlib';
+import type { StructureSource } from '../../structure/core/structureSource.ts';
+import type { LoadedInput } from './connectHost.ts';
+import type { CheckedValue } from './kinds.ts';
+/**
+ * The kinds a structure input accepts, in order of preference: a molfile
+ * carries the layout its author drew, an idcode the exact structure, a SMILES
+ * only the connectivity.
+ */
+export declare const STRUCTURE_KINDS: readonly ["chem.molfile", "chem.ocl.id", "chem.smiles"];
+/** A checked value holding a structure. */
+export type StructureValue = Extract<CheckedValue, {
+    kind: (typeof STRUCTURE_KINDS)[number];
+}>;
+/**
+ * The function a tool hands `useHostConnection` as `load` when its input is a
+ * structure.
+ *
+ * The structure is parsed before `show` is called, so one that cannot be read
+ * is answered `unreadable` with a sentence the host can show, and nothing on
+ * the tool's screen changes.
+ * @param show - Puts the molecule on screen, under the host's label for it.
+ * @param key - The input the structure arrives on.
+ * @returns The `load` function.
+ */
+export declare function hostStructureLoader(show: (molecule: Molecule, label: string | undefined) => void, key?: string): (inputs: readonly LoadedInput[]) => void;
+/**
+ * Read a structure a host sent.
+ *
+ * A molfile whose atoms all sit on one point — SciPeaks stores some that way —
+ * is laid out again, so a tool that draws it does not draw one dot.
+ * @param checked - The value, already checked against its kind.
+ * @returns A molecule with at least one atom.
+ * @throws {Error} When the notation does not parse or describes no atoms; the
+ * message is the sentence the host is answered with.
+ */
+export declare function readHostMolecule(checked: StructureValue): Molecule;
+/**
+ * A structure a host sent, as the notation a depiction is drawn from.
+ * @param checked - The value, already checked against its kind.
+ * @returns The notation and its text; an idcode keeps its coordinates.
+ */
+export declare function hostStructureSource(checked: StructureValue): StructureSource;
+//# sourceMappingURL=hostStructure.d.ts.map

package/lib/host/core/hostStructure.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"hostStructure.d.ts","sourceRoot":"","sources":["../../../src/host/core/hostStructure.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,aAAa,CAAC;AAI5C,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,yCAAyC,CAAC;AAE/E,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAC;AACpD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,YAAY,CAAC;AAE/C;;;;GAIG;AACH,eAAO,MAAM,eAAe,yDAIlB,CAAC;AAEX,2CAA2C;AAC3C,MAAM,MAAM,cAAc,GAAG,OAAO,CAClC,YAAY,EACZ;IAAE,IAAI,EAAE,CAAC,OAAO,eAAe,CAAC,CAAC,MAAM,CAAC,CAAA;CAAE,CAC3C,CAAC;AAEF;;;;;;;;;;GAUG;AACH,wBAAgB,mBAAmB,CACjC,IAAI,EAAE,CAAC,QAAQ,EAAE,QAAQ,EAAE,KAAK,EAAE,MAAM,GAAG,SAAS,KAAK,IAAI,EAC7D,GAAG,SAAc,GAChB,CAAC,MAAM,EAAE,SAAS,WAAW,EAAE,KAAK,IAAI,CAO1C;AAED;;;;;;;;;GASG;AACH,wBAAgB,gBAAgB,CAAC,OAAO,EAAE,cAAc,GAAG,QAAQ,CAmBlE;AAED;;;;GAIG;AACH,wBAAgB,mBAAmB,CAAC,OAAO,EAAE,cAAc,GAAG,eAAe,CAW5E"}

package/lib/host/core/hostStructure.js

@@ -0,0 +1,106 @@
+/**
+ * A structure a host handed over, read into the molecule a tool works on.
+ *
+ * Every tool of the family that takes a structure takes it the same way — in
+ * the three notations a notebook keeps, the one that says the most first — so
+ * the kinds, the parsing and the sentence a host reads when it fails are
+ * written once, here.
+ */
+import { sourceMolecule } from "../../structure/core/sourceMolecule.js";
+import { structureError } from "../../structure/core/structureError.js";
+/**
+ * The kinds a structure input accepts, in order of preference: a molfile
+ * carries the layout its author drew, an idcode the exact structure, a SMILES
+ * only the connectivity.
+ */
+export const STRUCTURE_KINDS = [
+    'chem.molfile',
+    'chem.ocl.id',
+    'chem.smiles',
+];
+/**
+ * The function a tool hands `useHostConnection` as `load` when its input is a
+ * structure.
+ *
+ * The structure is parsed before `show` is called, so one that cannot be read
+ * is answered `unreadable` with a sentence the host can show, and nothing on
+ * the tool's screen changes.
+ * @param show - Puts the molecule on screen, under the host's label for it.
+ * @param key - The input the structure arrives on.
+ * @returns The `load` function.
+ */
+export function hostStructureLoader(show, key = 'structure') {
+    return (inputs) => {
+        for (const { key: inputKey, item, checked } of inputs) {
+            if (inputKey !== key || !isStructureValue(checked))
+                continue;
+            show(readHostMolecule(checked), item.label);
+        }
+    };
+}
+/**
+ * Read a structure a host sent.
+ *
+ * A molfile whose atoms all sit on one point — SciPeaks stores some that way —
+ * is laid out again, so a tool that draws it does not draw one dot.
+ * @param checked - The value, already checked against its kind.
+ * @returns A molecule with at least one atom.
+ * @throws {Error} When the notation does not parse or describes no atoms; the
+ * message is the sentence the host is answered with.
+ */
+export function readHostMolecule(checked) {
+    const notation = NOTATIONS[checked.kind];
+    let molecule;
+    try {
+        molecule = sourceMolecule(hostStructureSource(checked));
+    }
+    catch (error) {
+        const { message } = structureError(error);
+        throw new Error(`The ${notation} could not be read, so nothing was loaded: ${message}`, { cause: error });
+    }
+    if (molecule.getAllAtoms() === 0) {
+        throw new Error(`The ${notation} describes no atoms, so nothing was loaded.`);
+    }
+    if (atomsCoincide(molecule))
+        molecule.inventCoordinates();
+    return molecule;
+}
+/**
+ * A structure a host sent, as the notation a depiction is drawn from.
+ * @param checked - The value, already checked against its kind.
+ * @returns The notation and its text; an idcode keeps its coordinates.
+ */
+export function hostStructureSource(checked) {
+    if (checked.kind === 'chem.molfile') {
+        return { kind: 'molfile', value: checked.value.molfile };
+    }
+    if (checked.kind === 'chem.ocl.id') {
+        const { idCode, coordinates } = checked.value;
+        return coordinates === ''
+            ? { kind: 'idcode', value: idCode }
+            : { kind: 'idcode', value: idCode, coordinates };
+    }
+    return { kind: 'smiles', value: checked.value.smiles.trim() };
+}
+const NOTATIONS = {
+    'chem.molfile': 'molfile',
+    'chem.ocl.id': 'idcode',
+    'chem.smiles': 'SMILES',
+};
+function atomsCoincide(molecule) {
+    const atoms = molecule.getAllAtoms();
+    if (atoms < 2)
+        return false;
+    const x = molecule.getAtomX(0);
+    const y = molecule.getAtomY(0);
+    for (let atom = 1; atom < atoms; atom++) {
+        if (molecule.getAtomX(atom) !== x || molecule.getAtomY(atom) !== y) {
+            return false;
+        }
+    }
+    return true;
+}
+function isStructureValue(checked) {
+    return Object.hasOwn(NOTATIONS, checked.kind);
+}
+//# sourceMappingURL=hostStructure.js.map

package/lib/host/core/hostStructure.js.map

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

package/lib/host/core/index.d.ts

@@ -0,0 +1,9 @@
+export type { HostConnectionOptions, HostMessageEvent, InputSelection, LoadedInput, } from './connectHost.ts';
+export { connectHost, selectInputs } from './connectHost.ts';
+export type { StructureValue } from './hostStructure.ts';
+export { STRUCTURE_KINDS, hostStructureLoader, hostStructureSource, readHostMolecule, } from './hostStructure.ts';
+export type { CheckOutcome, CheckedValue, KnownKind, MolfileValue, OclIdValue, SmilesValue, } from './kinds.ts';
+export { checkValue, isKnownKind, kindAccepts } from './kinds.ts';
+export type { GetRequest, HelloMessage, HostError, HostErrorCode, HostItem, HostRequest, LoadRequest, ResultMessage, ToolInput, ToolInterface, ToolOutput, UsedItem, } from './protocol.ts';
+export { CONNECT_TYPE, HELLO_TYPE, MAX_ITEMS, MAX_LABEL_LENGTH, PROTOCOL_VERSION, isConnect, parseRequest, } from './protocol.ts';
+//# sourceMappingURL=index.d.ts.map

package/lib/host/core/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/host/core/index.ts"],"names":[],"mappings":"AAAA,YAAY,EACV,qBAAqB,EACrB,gBAAgB,EAChB,cAAc,EACd,WAAW,GACZ,MAAM,kBAAkB,CAAC;AAC1B,OAAO,EAAE,WAAW,EAAE,YAAY,EAAE,MAAM,kBAAkB,CAAC;AAC7D,YAAY,EAAE,cAAc,EAAE,MAAM,oBAAoB,CAAC;AACzD,OAAO,EACL,eAAe,EACf,mBAAmB,EACnB,mBAAmB,EACnB,gBAAgB,GACjB,MAAM,oBAAoB,CAAC;AAC5B,YAAY,EACV,YAAY,EACZ,YAAY,EACZ,SAAS,EACT,YAAY,EACZ,UAAU,EACV,WAAW,GACZ,MAAM,YAAY,CAAC;AACpB,OAAO,EAAE,UAAU,EAAE,WAAW,EAAE,WAAW,EAAE,MAAM,YAAY,CAAC;AAClE,YAAY,EACV,UAAU,EACV,YAAY,EACZ,SAAS,EACT,aAAa,EACb,QAAQ,EACR,WAAW,EACX,WAAW,EACX,aAAa,EACb,SAAS,EACT,aAAa,EACb,UAAU,EACV,QAAQ,GACT,MAAM,eAAe,CAAC;AACvB,OAAO,EACL,YAAY,EACZ,UAAU,EACV,SAAS,EACT,gBAAgB,EAChB,gBAAgB,EAChB,SAAS,EACT,YAAY,GACb,MAAM,eAAe,CAAC"}

package/lib/host/core/index.js

@@ -0,0 +1,5 @@
+export { connectHost, selectInputs } from "./connectHost.js";
+export { STRUCTURE_KINDS, hostStructureLoader, hostStructureSource, readHostMolecule, } from "./hostStructure.js";
+export { checkValue, isKnownKind, kindAccepts } from "./kinds.js";
+export { CONNECT_TYPE, HELLO_TYPE, MAX_ITEMS, MAX_LABEL_LENGTH, PROTOCOL_VERSION, isConnect, parseRequest, } from "./protocol.js";
+//# sourceMappingURL=index.js.map

package/lib/host/core/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/host/core/index.ts"],"names":[],"mappings":"AAMA,OAAO,EAAE,WAAW,EAAE,YAAY,EAAE,MAAM,kBAAkB,CAAC;AAE7D,OAAO,EACL,eAAe,EACf,mBAAmB,EACnB,mBAAmB,EACnB,gBAAgB,GACjB,MAAM,oBAAoB,CAAC;AAS5B,OAAO,EAAE,UAAU,EAAE,WAAW,EAAE,WAAW,EAAE,MAAM,YAAY,CAAC;AAelE,OAAO,EACL,YAAY,EACZ,UAAU,EACV,SAAS,EACT,gBAAgB,EAChB,gBAAgB,EAChB,SAAS,EACT,YAAY,GACb,MAAM,eAAe,CAAC"}

package/lib/host/core/kinds.d.ts

@@ -0,0 +1,73 @@
+/**
+ * The kinds of data a tool takes from a host, checked the way
+ * pipeline.cheminfo.org checks what its workers pass to each other: a dotted
+ * name, a JSON Schema, and ajv.
+ *
+ * The names are pipeline's (`chem.molfile.2d`, `chem.ocl.id`…), plus
+ * `chem.smiles`, which pipeline lists among its future schemas. A name with
+ * children is a category whose schema every child satisfies, so `chem.molfile`
+ * reads `chem.molfile.2d` and `chem.molfile.3d.h.energy` alike; the fields a
+ * tool does not read are stripped rather than refused, so a host sending more
+ * than it needs to is never turned away.
+ */
+/** A molfile, V2000 or V3000. */
+export interface MolfileValue {
+    molfile: string;
+}
+/** An OpenChemLib idcode and its 2D coordinates. */
+export interface OclIdValue {
+    idCode: string;
+    coordinates: string;
+}
+/** A SMILES. */
+export interface SmilesValue {
+    smiles: string;
+}
+/** A value that passed its kind's schema, tagged with that kind. */
+export type CheckedValue = {
+    kind: 'chem.molfile';
+    value: MolfileValue;
+} | {
+    kind: 'chem.ocl.id';
+    value: OclIdValue;
+} | {
+    kind: 'chem.smiles';
+    value: SmilesValue;
+};
+/** The name of a kind a tool can read. */
+export type KnownKind = CheckedValue['kind'];
+/** What checking a value gave. */
+export type CheckOutcome = {
+    valid: true;
+    checked: CheckedValue;
+} | {
+    valid: false;
+    errors: string[];
+};
+/**
+ * Whether a kind falls under another: the same name, or a name under it on a
+ * segment boundary. A list (`…[]`) never stands for one value, nor one value
+ * for a list.
+ * @param accepted - The kind a tool declares, e.g. `'chem.molfile'`.
+ * @param offered - The kind an item carries, e.g. `'chem.molfile.2d'`.
+ * @returns `true` when an item of `offered` can be read as `accepted`.
+ */
+export declare function kindAccepts(accepted: string, offered: string): boolean;
+/**
+ * Whether there is a schema for a kind.
+ * @param kind - A kind name.
+ * @returns `true` for a {@link KnownKind}.
+ */
+export declare function isKnownKind(kind: string): kind is KnownKind;
+/**
+ * Check a value against a kind's schema.
+ *
+ * Fields the schema does not name are removed from `value` itself, so what the
+ * site reads afterwards is exactly what the kind promises.
+ * @param kind - The kind to read the value as.
+ * @param value - The value, as received.
+ * @returns The value tagged with its kind, or the errors as pipeline writes
+ * them, `'/idCode: must be string'`.
+ */
+export declare function checkValue(kind: KnownKind, value: unknown): CheckOutcome;
+//# sourceMappingURL=kinds.d.ts.map

package/lib/host/core/kinds.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"kinds.d.ts","sourceRoot":"","sources":["../../../src/host/core/kinds.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAKH,iCAAiC;AACjC,MAAM,WAAW,YAAY;IAC3B,OAAO,EAAE,MAAM,CAAC;CACjB;AAED,oDAAoD;AACpD,MAAM,WAAW,UAAU;IACzB,MAAM,EAAE,MAAM,CAAC;IACf,WAAW,EAAE,MAAM,CAAC;CACrB;AAED,gBAAgB;AAChB,MAAM,WAAW,WAAW;IAC1B,MAAM,EAAE,MAAM,CAAC;CAChB;AAED,oEAAoE;AACpE,MAAM,MAAM,YAAY,GACpB;IAAE,IAAI,EAAE,cAAc,CAAC;IAAC,KAAK,EAAE,YAAY,CAAA;CAAE,GAC7C;IAAE,IAAI,EAAE,aAAa,CAAC;IAAC,KAAK,EAAE,UAAU,CAAA;CAAE,GAC1C;IAAE,IAAI,EAAE,aAAa,CAAC;IAAC,KAAK,EAAE,WAAW,CAAA;CAAE,CAAC;AAEhD,0CAA0C;AAC1C,MAAM,MAAM,SAAS,GAAG,YAAY,CAAC,MAAM,CAAC,CAAC;AAK7C,kCAAkC;AAClC,MAAM,MAAM,YAAY,GACtB;IAAE,KAAK,EAAE,IAAI,CAAC;IAAC,OAAO,EAAE,YAAY,CAAA;CAAE,GAAG;IAAE,KAAK,EAAE,KAAK,CAAC;IAAC,MAAM,EAAE,MAAM,EAAE,CAAA;CAAE,CAAC;AAE9E;;;;;;;GAOG;AACH,wBAAgB,WAAW,CAAC,QAAQ,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,OAAO,CAMtE;AAED;;;;GAIG;AACH,wBAAgB,WAAW,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI,IAAI,SAAS,CAE3D;AAED;;;;;;;;;GASG;AACH,wBAAgB,UAAU,CAAC,IAAI,EAAE,SAAS,EAAE,KAAK,EAAE,OAAO,GAAG,YAAY,CAWxE"}