react-cheminfo 0.3.0 → 0.4.0

package/lib/structure/core/readStructure.js

@@ -0,0 +1,59 @@
+import { looksLikeMolfile } from "./molfile.js";
+/**
+ * Decide what a piece of text is, without parsing it.
+ *
+ * Nothing is asked of the user, because the answer is in the text: a molfile
+ * carries a version stamp and several lines, a query carries syntax that only
+ * exists in SMARTS, and whatever is left is a SMILES. Text that holds nothing
+ * is the third answer, so a field can tell "not typed yet" from "typed
+ * something wrong" and only complain about the second.
+ * @param text - The structure, as typed, pasted or dropped.
+ * @returns The notation and the text to read it with.
+ */
+export function readStructure(text) {
+    const trimmed = text.trim();
+    if (trimmed === '')
+        return { kind: 'empty', value: '' };
+    if (looksLikeMolfile(text))
+        return { kind: 'molfile', value: text };
+    if (looksLikeSmarts(trimmed))
+        return { kind: 'smarts', value: trimmed };
+    return { kind: 'smiles', value: trimmed };
+}
+/**
+ * Whether a line notation uses syntax that exists in SMARTS and not in SMILES.
+ *
+ * Only the inside of a bracket atom is inspected for the primitives, because
+ * `#` is a triple bond outside one and `D`, `X`, `R`, `v` and `h` are the
+ * start of real element symbols. `~`, `&`, `,`, `;`, `!` and `$(` are SMARTS
+ * anywhere they appear.
+ * @param text - The line notation, already trimmed.
+ * @returns True when it can only be a query.
+ */
+export function looksLikeSmarts(text) {
+    if (/[~&;,!]/.test(text) || text.includes('$('))
+        return true;
+    for (const match of text.matchAll(BRACKET_ATOM)) {
+        if (QUERY_PRIMITIVE.test(match.groups?.atom ?? ''))
+            return true;
+    }
+    return BARE_WILDCARD.test(text.replaceAll(BRACKET_ATOM, ''));
+}
+const BRACKET_ATOM = /\[(?<atom>[^\]]*)\]/g;
+/**
+ * `#6` (atomic number), `X3` / `D2` / `R1` / `r5` / `v4` / `h1` / `x2`
+ * (counts), and the `a` / `A` wildcards. A digit is required after the letter,
+ * so `[Xe]` and `[Rn]` stay elements. The wildcard is anchored to the start of
+ * the atom, after an optional isotope: unanchored it matches the `a` of
+ * `[Na+]`, and every bracketed element holding a lowercase a — Na, Ca, Ba, La,
+ * Ta — would then read as a query rather than as the atom it is.
+ */
+const QUERY_PRIMITIVE = /#\d|[DXRrvhx]\d|^\*|^\d*[aA](?![a-z])/;
+/**
+ * Outside a bracket the wildcard has to stand on its own: a letter on either
+ * side and it is part of a word, not a pattern. Widening this to any `a` or
+ * `A` reads the header `CAS` as the three-atom SMARTS `C`,`A`,`S`, and a
+ * spreadsheet's header row stops being recognised as one.
+ */
+const BARE_WILDCARD = /(?:^|[^A-Za-z])[aA](?![a-z])/;
+//# sourceMappingURL=readStructure.js.map

package/lib/structure/core/readStructure.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"readStructure.js","sourceRoot":"","sources":["../../../src/structure/core/readStructure.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,gBAAgB,EAAE,MAAM,cAAc,CAAC;AAiBhD;;;;;;;;;;GAUG;AACH,MAAM,UAAU,aAAa,CAAC,IAAY;IACxC,MAAM,OAAO,GAAG,IAAI,CAAC,IAAI,EAAE,CAAC;IAC5B,IAAI,OAAO,KAAK,EAAE;QAAE,OAAO,EAAE,IAAI,EAAE,OAAO,EAAE,KAAK,EAAE,EAAE,EAAE,CAAC;IACxD,IAAI,gBAAgB,CAAC,IAAI,CAAC;QAAE,OAAO,EAAE,IAAI,EAAE,SAAS,EAAE,KAAK,EAAE,IAAI,EAAE,CAAC;IACpE,IAAI,eAAe,CAAC,OAAO,CAAC;QAAE,OAAO,EAAE,IAAI,EAAE,QAAQ,EAAE,KAAK,EAAE,OAAO,EAAE,CAAC;IACxE,OAAO,EAAE,IAAI,EAAE,QAAQ,EAAE,KAAK,EAAE,OAAO,EAAE,CAAC;AAC5C,CAAC;AAED;;;;;;;;;GASG;AACH,MAAM,UAAU,eAAe,CAAC,IAAY;IAC1C,IAAI,SAAS,CAAC,IAAI,CAAC,IAAI,CAAC,IAAI,IAAI,CAAC,QAAQ,CAAC,IAAI,CAAC;QAAE,OAAO,IAAI,CAAC;IAC7D,KAAK,MAAM,KAAK,IAAI,IAAI,CAAC,QAAQ,CAAC,YAAY,CAAC,EAAE,CAAC;QAChD,IAAI,eAAe,CAAC,IAAI,CAAC,KAAK,CAAC,MAAM,EAAE,IAAI,IAAI,EAAE,CAAC;YAAE,OAAO,IAAI,CAAC;IAClE,CAAC;IACD,OAAO,aAAa,CAAC,IAAI,CAAC,IAAI,CAAC,UAAU,CAAC,YAAY,EAAE,EAAE,CAAC,CAAC,CAAC;AAC/D,CAAC;AAED,MAAM,YAAY,GAAG,sBAAsB,CAAC;AAE5C;;;;;;;GAOG;AACH,MAAM,eAAe,GAAG,uCAAuC,CAAC;AAEhE;;;;;GAKG;AACH,MAAM,aAAa,GAAG,8BAA8B,CAAC"}

package/lib/structure/core/structureSource.d.ts

@@ -0,0 +1,34 @@
+/** Every notation a read-only depiction may be handed. */
+export interface StructureSourceInput {
+    /** A canonical openchemlib idCode, coordinates included or not. */
+    idCode?: string;
+    /** Encoded 2D coordinates, when they did not travel with the idCode. */
+    coordinates?: string;
+    /** A molfile, V2000 or V3000. */
+    molfile?: string;
+    /** A SMILES. */
+    smiles?: string;
+}
+/** The one notation a depiction should be drawn from. */
+export interface StructureSource {
+    /** Which notation was picked; `empty` when none of them holds a structure. */
+    kind: 'idcode' | 'molfile' | 'smiles' | 'empty';
+    /** The text to draw, empty when there is nothing to draw. */
+    value: string;
+    /** Encoded 2D coordinates, only ever set beside an idCode. */
+    coordinates?: string;
+}
+/**
+ * Pick the notation a depiction is drawn from when several were supplied.
+ *
+ * The most exact one wins: an idCode says precisely which structure, a molfile
+ * additionally carries the layout its author chose, and a SMILES leaves the
+ * layout to be invented. A notation that describes nothing — a blank string, a
+ * molfile with an empty atom block, the idCode an erased canvas leaves behind
+ * — is skipped rather than drawn, which is what turns a broken box into the
+ * next best picture, or into an honest placeholder.
+ * @param input - Whatever notations the caller has.
+ * @returns The notation to draw, and the text to draw it from.
+ */
+export declare function structureSource(input: StructureSourceInput): StructureSource;
+//# sourceMappingURL=structureSource.d.ts.map

package/lib/structure/core/structureSource.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"structureSource.d.ts","sourceRoot":"","sources":["../../../src/structure/core/structureSource.ts"],"names":[],"mappings":"AAGA,0DAA0D;AAC1D,MAAM,WAAW,oBAAoB;IACnC,mEAAmE;IACnE,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,wEAAwE;IACxE,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,iCAAiC;IACjC,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,gBAAgB;IAChB,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB;AAED,yDAAyD;AACzD,MAAM,WAAW,eAAe;IAC9B,8EAA8E;IAC9E,IAAI,EAAE,QAAQ,GAAG,SAAS,GAAG,QAAQ,GAAG,OAAO,CAAC;IAChD,6DAA6D;IAC7D,KAAK,EAAE,MAAM,CAAC;IACd,8DAA8D;IAC9D,WAAW,CAAC,EAAE,MAAM,CAAC;CACtB;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,eAAe,CAAC,KAAK,EAAE,oBAAoB,GAAG,eAAe,CAmB5E"}

package/lib/structure/core/structureSource.js

@@ -0,0 +1,32 @@
+import { isEmptyIdCode, splitIdCode } from "./editorValue.js";
+import { molfileAtomCount } from "./molfile.js";
+/**
+ * Pick the notation a depiction is drawn from when several were supplied.
+ *
+ * The most exact one wins: an idCode says precisely which structure, a molfile
+ * additionally carries the layout its author chose, and a SMILES leaves the
+ * layout to be invented. A notation that describes nothing — a blank string, a
+ * molfile with an empty atom block, the idCode an erased canvas leaves behind
+ * — is skipped rather than drawn, which is what turns a broken box into the
+ * next best picture, or into an honest placeholder.
+ * @param input - Whatever notations the caller has.
+ * @returns The notation to draw, and the text to draw it from.
+ */
+export function structureSource(input) {
+    const { idCode, coordinates, molfile, smiles } = input;
+    if (idCode !== undefined && !isEmptyIdCode(idCode)) {
+        const split = splitIdCode(idCode);
+        const layout = split.coordinates ?? coordinates;
+        return layout === undefined || layout === ''
+            ? { kind: 'idcode', value: split.idCode }
+            : { kind: 'idcode', value: split.idCode, coordinates: layout };
+    }
+    if (molfile !== undefined && molfileAtomCount(molfile) > 0) {
+        return { kind: 'molfile', value: molfile };
+    }
+    const line = smiles?.trim() ?? '';
+    if (line !== '')
+        return { kind: 'smiles', value: line };
+    return { kind: 'empty', value: '' };
+}
+//# sourceMappingURL=structureSource.js.map

package/lib/structure/core/structureSource.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"structureSource.js","sourceRoot":"","sources":["../../../src/structure/core/structureSource.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAC;AAC9D,OAAO,EAAE,gBAAgB,EAAE,MAAM,cAAc,CAAC;AAwBhD;;;;;;;;;;;GAWG;AACH,MAAM,UAAU,eAAe,CAAC,KAA2B;IACzD,MAAM,EAAE,MAAM,EAAE,WAAW,EAAE,OAAO,EAAE,MAAM,EAAE,GAAG,KAAK,CAAC;IAEvD,IAAI,MAAM,KAAK,SAAS,IAAI,CAAC,aAAa,CAAC,MAAM,CAAC,EAAE,CAAC;QACnD,MAAM,KAAK,GAAG,WAAW,CAAC,MAAM,CAAC,CAAC;QAClC,MAAM,MAAM,GAAG,KAAK,CAAC,WAAW,IAAI,WAAW,CAAC;QAChD,OAAO,MAAM,KAAK,SAAS,IAAI,MAAM,KAAK,EAAE;YAC1C,CAAC,CAAC,EAAE,IAAI,EAAE,QAAQ,EAAE,KAAK,EAAE,KAAK,CAAC,MAAM,EAAE;YACzC,CAAC,CAAC,EAAE,IAAI,EAAE,QAAQ,EAAE,KAAK,EAAE,KAAK,CAAC,MAAM,EAAE,WAAW,EAAE,MAAM,EAAE,CAAC;IACnE,CAAC;IAED,IAAI,OAAO,KAAK,SAAS,IAAI,gBAAgB,CAAC,OAAO,CAAC,GAAG,CAAC,EAAE,CAAC;QAC3D,OAAO,EAAE,IAAI,EAAE,SAAS,EAAE,KAAK,EAAE,OAAO,EAAE,CAAC;IAC7C,CAAC;IAED,MAAM,IAAI,GAAG,MAAM,EAAE,IAAI,EAAE,IAAI,EAAE,CAAC;IAClC,IAAI,IAAI,KAAK,EAAE;QAAE,OAAO,EAAE,IAAI,EAAE,QAAQ,EAAE,KAAK,EAAE,IAAI,EAAE,CAAC;IAExD,OAAO,EAAE,IAAI,EAAE,OAAO,EAAE,KAAK,EAAE,EAAE,EAAE,CAAC;AACtC,CAAC"}

package/lib/structure/core/toolbarFloor.d.ts

@@ -0,0 +1,16 @@
+/** The two 1px borders of a container that sizes itself border-box. */
+export declare const TOOLBAR_BORDERS = 2;
+/**
+ * The smallest height a drawing editor's container may take.
+ *
+ * The editor's toolbar is a canvas of a fixed height, drawn from a sprite of a
+ * fixed number of buttons: a container any shorter than that does not scroll,
+ * it simply cuts the last buttons off. So the floor is whichever is taller,
+ * the height the caller asked for or the toolbar plus the borders around it.
+ * @param toolbarHeight - Height the toolbar was measured at, in pixels.
+ * @param minHeight - Smallest height the caller asked for, in pixels.
+ * @param borders - Borders the container adds around the toolbar, in pixels.
+ * @returns The height to give the container, in pixels.
+ */
+export declare function toolbarFloorHeight(toolbarHeight: number, minHeight: number, borders?: number): number;
+//# sourceMappingURL=toolbarFloor.d.ts.map

package/lib/structure/core/toolbarFloor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"toolbarFloor.d.ts","sourceRoot":"","sources":["../../../src/structure/core/toolbarFloor.ts"],"names":[],"mappings":"AAAA,uEAAuE;AACvE,eAAO,MAAM,eAAe,IAAI,CAAC;AAEjC;;;;;;;;;;;GAWG;AACH,wBAAgB,kBAAkB,CAChC,aAAa,EAAE,MAAM,EACrB,SAAS,EAAE,MAAM,EACjB,OAAO,GAAE,MAAwB,GAChC,MAAM,CAOR"}

package/lib/structure/core/toolbarFloor.js

@@ -0,0 +1,27 @@
+/** The two 1px borders of a container that sizes itself border-box. */
+export const TOOLBAR_BORDERS = 2;
+/**
+ * The smallest height a drawing editor's container may take.
+ *
+ * The editor's toolbar is a canvas of a fixed height, drawn from a sprite of a
+ * fixed number of buttons: a container any shorter than that does not scroll,
+ * it simply cuts the last buttons off. So the floor is whichever is taller,
+ * the height the caller asked for or the toolbar plus the borders around it.
+ * @param toolbarHeight - Height the toolbar was measured at, in pixels.
+ * @param minHeight - Smallest height the caller asked for, in pixels.
+ * @param borders - Borders the container adds around the toolbar, in pixels.
+ * @returns The height to give the container, in pixels.
+ */
+export function toolbarFloorHeight(toolbarHeight, minHeight, borders = TOOLBAR_BORDERS) {
+    const asked = positive(minHeight);
+    const measured = positive(toolbarHeight);
+    // A toolbar with no layout yet measures zero, and a floor of two pixels of
+    // border would collapse the editor before it has had a chance to draw.
+    if (measured === 0)
+        return asked;
+    return Math.max(asked, measured + positive(borders));
+}
+function positive(value) {
+    return Number.isFinite(value) && value > 0 ? value : 0;
+}
+//# sourceMappingURL=toolbarFloor.js.map

package/lib/structure/core/toolbarFloor.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"toolbarFloor.js","sourceRoot":"","sources":["../../../src/structure/core/toolbarFloor.ts"],"names":[],"mappings":"AAAA,uEAAuE;AACvE,MAAM,CAAC,MAAM,eAAe,GAAG,CAAC,CAAC;AAEjC;;;;;;;;;;;GAWG;AACH,MAAM,UAAU,kBAAkB,CAChC,aAAqB,EACrB,SAAiB,EACjB,UAAkB,eAAe;IAEjC,MAAM,KAAK,GAAG,QAAQ,CAAC,SAAS,CAAC,CAAC;IAClC,MAAM,QAAQ,GAAG,QAAQ,CAAC,aAAa,CAAC,CAAC;IACzC,2EAA2E;IAC3E,uEAAuE;IACvE,IAAI,QAAQ,KAAK,CAAC;QAAE,OAAO,KAAK,CAAC;IACjC,OAAO,IAAI,CAAC,GAAG,CAAC,KAAK,EAAE,QAAQ,GAAG,QAAQ,CAAC,OAAO,CAAC,CAAC,CAAC;AACvD,CAAC;AAED,SAAS,QAAQ,CAAC,KAAa;IAC7B,OAAO,MAAM,CAAC,QAAQ,CAAC,KAAK,CAAC,IAAI,KAAK,GAAG,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC;AACzD,CAAC"}

package/lib/structure/ui/EditorCanvas.d.ts

@@ -0,0 +1,55 @@
+import type { ReactElement } from 'react';
+import type { CanvasEditorInputFormat } from 'react-ocl';
+/** What the editor draws: one structure, or a reaction with its arrow. */
+export type StructureEditorMode = 'molecule' | 'reaction';
+/** Everything the editor holds at the moment it changed. */
+export interface StructureEditorChange {
+    /** Which kind of editor produced it. */
+    mode: StructureEditorMode;
+    /**
+     * The idCode, with the coordinates the editor laid out written after a
+     * space. `splitIdCode` takes the two apart.
+     */
+    idCode: string;
+    /** The V2000 molfile of a molecule, or the RXN file of a reaction. */
+    molfile: string;
+    /** The SMILES of a molecule, or the reaction SMILES. */
+    smiles: string;
+}
+export interface EditorCanvasProps {
+    /** Called on every stroke, with the editor read out synchronously. */
+    onChange: (change: StructureEditorChange) => void;
+    /**
+     * Draw a query fragment rather than a whole structure, which is what a
+     * substructure filter needs.
+     * @default false
+     */
+    fragment?: boolean;
+    /**
+     * How `value` is written.
+     * @default 'idcode'
+     */
+    inputFormat?: CanvasEditorInputFormat;
+    /**
+     * What the canvas holds when it appears. Read once, at mount: the editor is
+     * uncontrolled, so feeding a later value back would replace the structure
+     * and reset every coordinate under the pen.
+     * @default ''
+     */
+    value?: string;
+    /**
+     * Whether the editor draws one structure or a reaction.
+     * @default 'molecule'
+     */
+    mode?: StructureEditorMode;
+}
+/**
+ * The react-ocl canvas, filling whatever box it is put in.
+ *
+ * Its value is frozen at mount, so the caller remounts it — by changing its
+ * `key` — to load a different structure into it.
+ * @param props - What to draw, how it is written, and where to send it.
+ * @returns The canvas.
+ */
+export declare function EditorCanvas(props: EditorCanvasProps): ReactElement;
+//# sourceMappingURL=EditorCanvas.d.ts.map

package/lib/structure/ui/EditorCanvas.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"EditorCanvas.d.ts","sourceRoot":"","sources":["../../../src/structure/ui/EditorCanvas.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAiB,YAAY,EAAE,MAAM,OAAO,CAAC;AAEzD,OAAO,KAAK,EACV,uBAAuB,EAGxB,MAAM,WAAW,CAAC;AAGnB,0EAA0E;AAC1E,MAAM,MAAM,mBAAmB,GAAG,UAAU,GAAG,UAAU,CAAC;AAE1D,4DAA4D;AAC5D,MAAM,WAAW,qBAAqB;IACpC,wCAAwC;IACxC,IAAI,EAAE,mBAAmB,CAAC;IAC1B;;;OAGG;IACH,MAAM,EAAE,MAAM,CAAC;IACf,sEAAsE;IACtE,OAAO,EAAE,MAAM,CAAC;IAChB,wDAAwD;IACxD,MAAM,EAAE,MAAM,CAAC;CAChB;AAED,MAAM,WAAW,iBAAiB;IAChC,sEAAsE;IACtE,QAAQ,EAAE,CAAC,MAAM,EAAE,qBAAqB,KAAK,IAAI,CAAC;IAClD;;;;OAIG;IACH,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB;;;OAGG;IACH,WAAW,CAAC,EAAE,uBAAuB,CAAC;IACtC;;;;;OAKG;IACH,KAAK,CAAC,EAAE,MAAM,CAAC;IACf;;;OAGG;IACH,IAAI,CAAC,EAAE,mBAAmB,CAAC;CAC5B;AAED;;;;;;;GAOG;AACH,wBAAgB,YAAY,CAAC,KAAK,EAAE,iBAAiB,GAAG,YAAY,CA2DnE"}

package/lib/structure/ui/EditorCanvas.js

@@ -0,0 +1,41 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { useCallback, useState } from 'react';
+import { CanvasMoleculeEditor, CanvasReactionEditor } from 'react-ocl';
+/**
+ * The react-ocl canvas, filling whatever box it is put in.
+ *
+ * Its value is frozen at mount, so the caller remounts it — by changing its
+ * `key` — to load a different structure into it.
+ * @param props - What to draw, how it is written, and where to send it.
+ * @returns The canvas.
+ */
+export function EditorCanvas(props) {
+    const { onChange, fragment = false, inputFormat = 'idcode', value = '', mode = 'molecule', } = props;
+    const [initialValue] = useState(value);
+    const handleMolecule = useCallback((event) => {
+        // The event describes the editor only while the callback runs, so every
+        // notation is read now and whatever waiting there is happens afterwards.
+        onChange({
+            mode: 'molecule',
+            idCode: event.getIdcode(),
+            molfile: event.getMolfile(),
+            smiles: event.getSmiles(),
+        });
+    }, [onChange]);
+    const handleReaction = useCallback((event) => {
+        onChange({
+            mode: 'reaction',
+            idCode: event.getIdcode(),
+            molfile: event.getRxn(),
+            smiles: event.getSmiles(),
+        });
+    }, [onChange]);
+    return (_jsx("div", { style: CANVAS_STYLE, children: mode === 'reaction' ? (_jsx(CanvasReactionEditor, { width: "100%", height: "100%", fragment: fragment, inputFormat: inputFormat, inputValue: initialValue, onChange: handleReaction })) : (_jsx(CanvasMoleculeEditor, { width: "100%", height: "100%", fragment: fragment, inputFormat: inputFormat, inputValue: initialValue, onChange: handleMolecule })) }));
+}
+/**
+ * The canvas measures its container in pixels, so it is taken out of the
+ * height computation: otherwise the container and the canvas grow each other
+ * without ever settling.
+ */
+const CANVAS_STYLE = { position: 'absolute', inset: 0 };
+//# sourceMappingURL=EditorCanvas.js.map

package/lib/structure/ui/EditorCanvas.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"EditorCanvas.js","sourceRoot":"","sources":["../../../src/structure/ui/EditorCanvas.tsx"],"names":[],"mappings":";AACA,OAAO,EAAE,WAAW,EAAE,QAAQ,EAAE,MAAM,OAAO,CAAC;AAM9C,OAAO,EAAE,oBAAoB,EAAE,oBAAoB,EAAE,MAAM,WAAW,CAAC;AAgDvE;;;;;;;GAOG;AACH,MAAM,UAAU,YAAY,CAAC,KAAwB;IACnD,MAAM,EACJ,QAAQ,EACR,QAAQ,GAAG,KAAK,EAChB,WAAW,GAAG,QAAQ,EACtB,KAAK,GAAG,EAAE,EACV,IAAI,GAAG,UAAU,GAClB,GAAG,KAAK,CAAC;IACV,MAAM,CAAC,YAAY,CAAC,GAAG,QAAQ,CAAC,KAAK,CAAC,CAAC;IAEvC,MAAM,cAAc,GAAG,WAAW,CAChC,CAAC,KAAmC,EAAE,EAAE;QACtC,wEAAwE;QACxE,yEAAyE;QACzE,QAAQ,CAAC;YACP,IAAI,EAAE,UAAU;YAChB,MAAM,EAAE,KAAK,CAAC,SAAS,EAAE;YACzB,OAAO,EAAE,KAAK,CAAC,UAAU,EAAE;YAC3B,MAAM,EAAE,KAAK,CAAC,SAAS,EAAE;SAC1B,CAAC,CAAC;IACL,CAAC,EACD,CAAC,QAAQ,CAAC,CACX,CAAC;IAEF,MAAM,cAAc,GAAG,WAAW,CAChC,CAAC,KAAmC,EAAE,EAAE;QACtC,QAAQ,CAAC;YACP,IAAI,EAAE,UAAU;YAChB,MAAM,EAAE,KAAK,CAAC,SAAS,EAAE;YACzB,OAAO,EAAE,KAAK,CAAC,MAAM,EAAE;YACvB,MAAM,EAAE,KAAK,CAAC,SAAS,EAAE;SAC1B,CAAC,CAAC;IACL,CAAC,EACD,CAAC,QAAQ,CAAC,CACX,CAAC;IAEF,OAAO,CACL,cAAK,KAAK,EAAE,YAAY,YACrB,IAAI,KAAK,UAAU,CAAC,CAAC,CAAC,CACrB,KAAC,oBAAoB,IACnB,KAAK,EAAC,MAAM,EACZ,MAAM,EAAC,MAAM,EACb,QAAQ,EAAE,QAAQ,EAClB,WAAW,EAAE,WAAW,EACxB,UAAU,EAAE,YAAY,EACxB,QAAQ,EAAE,cAAc,GACxB,CACH,CAAC,CAAC,CAAC,CACF,KAAC,oBAAoB,IACnB,KAAK,EAAC,MAAM,EACZ,MAAM,EAAC,MAAM,EACb,QAAQ,EAAE,QAAQ,EAClB,WAAW,EAAE,WAAW,EACxB,UAAU,EAAE,YAAY,EACxB,QAAQ,EAAE,cAAc,GACxB,CACH,GACG,CACP,CAAC;AACJ,CAAC;AAED;;;;GAIG;AACH,MAAM,YAAY,GAAkB,EAAE,QAAQ,EAAE,UAAU,EAAE,KAAK,EAAE,CAAC,EAAE,CAAC"}

package/lib/structure/ui/Structure.d.ts

@@ -0,0 +1,122 @@
+/**
+ * A read-only depiction of a structure, whichever notation the caller has.
+ *
+ * Which notation is drawn, and what is shown when there is nothing to draw, is
+ * decided here; the drawing itself sits behind `React.lazy`, so a page that
+ * never renders a structure never downloads react-ocl and openchemlib for one.
+ * That is also what lets `react-cheminfo/structure` be imported at all when
+ * those optional peers are not installed.
+ */
+import type { ReactElement, ReactNode } from 'react';
+/** What is written on a depiction besides the atoms and the bonds. */
+export interface StructureLabels {
+    /**
+     * Write the index of every atom next to it.
+     * @default false
+     */
+    atoms?: boolean;
+    /**
+     * Write the index of every bond next to it.
+     * @default false
+     */
+    bonds?: boolean;
+    /**
+     * Write the reaction mapping number of every mapped atom.
+     * @default false
+     */
+    mapping?: boolean;
+    /**
+     * A caption drawn inside the picture, under the structure.
+     * @default undefined
+     */
+    caption?: string;
+}
+export interface StructureProps {
+    /**
+     * A canonical openchemlib idCode, coordinates included or not. The most
+     * exact notation, so it is drawn in preference to the others.
+     * @default undefined
+     */
+    idCode?: string;
+    /**
+     * Encoded 2D coordinates, when they did not travel with the idCode.
+     * @default undefined
+     */
+    coordinates?: string;
+    /**
+     * A molfile, V2000 or V3000, drawn when there is no usable idCode.
+     * @default undefined
+     */
+    molfile?: string;
+    /**
+     * A SMILES, drawn when there is neither an idCode nor a molfile. The layout
+     * is invented, so two depictions of the same molecule may differ.
+     * @default undefined
+     */
+    smiles?: string;
+    /**
+     * Width of the picture, in pixels.
+     * @default 200
+     */
+    width?: number;
+    /**
+     * Height of the picture, in pixels.
+     * @default 140
+     */
+    height?: number;
+    /**
+     * What is written on the picture besides the structure itself.
+     * @default {}
+     */
+    labels?: StructureLabels;
+    /**
+     * Crop the picture to the atoms rather than centring them in the box.
+     * @default true
+     */
+    autoCrop?: boolean;
+    /**
+     * Blank space kept around the structure when it is cropped, in pixels.
+     * @default 4
+     */
+    autoCropMargin?: number;
+    /**
+     * Atoms to paint, which is how a substructure match is shown.
+     * @default undefined
+     */
+    atomHighlight?: number[];
+    /**
+     * The colour the highlighted atoms are painted.
+     * @default '#a5d8ff'
+     */
+    atomHighlightColor?: string;
+    /**
+     * Bonds to paint.
+     * @default undefined
+     */
+    bondHighlight?: number[];
+    /**
+     * The colour the highlighted bonds are painted.
+     * @default '#ffd8a8'
+     */
+    bondHighlightColor?: string;
+    /**
+     * What is shown when there is no structure, or when the one supplied cannot
+     * be read. An em dash rather than a red box: a missing structure is a row of
+     * a table far more often than it is a bug worth shouting about.
+     * @default '—'
+     */
+    fallback?: ReactNode;
+}
+/**
+ * Draw a structure, from whichever notation the caller has.
+ *
+ * Nothing here throws and nothing renders a broken box: a blank value, a
+ * molfile with an empty atom block and a SMILES with a typo in it all come out
+ * as the same quiet placeholder, sized like the picture that would have been
+ * drawn so a list of structures keeps its rhythm. The box the renderers load
+ * into is that same placeholder, so nothing moves once they arrive.
+ * @param props - The structure, its size and what is written on it.
+ * @returns The picture, or the placeholder.
+ */
+export declare function Structure(props: StructureProps): ReactElement;
+//# sourceMappingURL=Structure.d.ts.map

package/lib/structure/ui/Structure.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Structure.d.ts","sourceRoot":"","sources":["../../../src/structure/ui/Structure.tsx"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,OAAO,KAAK,EAAE,YAAY,EAAE,SAAS,EAAE,MAAM,OAAO,CAAC;AAYrD,sEAAsE;AACtE,MAAM,WAAW,eAAe;IAC9B;;;OAGG;IACH,KAAK,CAAC,EAAE,OAAO,CAAC;IAChB;;;OAGG;IACH,KAAK,CAAC,EAAE,OAAO,CAAC;IAChB;;;OAGG;IACH,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB;;;OAGG;IACH,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB;AAED,MAAM,WAAW,cAAc;IAC7B;;;;OAIG;IACH,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB;;;OAGG;IACH,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB;;;OAGG;IACH,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB;;;;OAIG;IACH,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB;;;OAGG;IACH,KAAK,CAAC,EAAE,MAAM,CAAC;IACf;;;OAGG;IACH,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB;;;OAGG;IACH,MAAM,CAAC,EAAE,eAAe,CAAC;IACzB;;;OAGG;IACH,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB;;;OAGG;IACH,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB;;;OAGG;IACH,aAAa,CAAC,EAAE,MAAM,EAAE,CAAC;IACzB;;;OAGG;IACH,kBAAkB,CAAC,EAAE,MAAM,CAAC;IAC5B;;;OAGG;IACH,aAAa,CAAC,EAAE,MAAM,EAAE,CAAC;IACzB;;;OAGG;IACH,kBAAkB,CAAC,EAAE,MAAM,CAAC;IAC5B;;;;;OAKG;IACH,QAAQ,CAAC,EAAE,SAAS,CAAC;CACtB;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,SAAS,CAAC,KAAK,EAAE,cAAc,GAAG,YAAY,CAgD7D"}

package/lib/structure/ui/Structure.js

@@ -0,0 +1,28 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { Suspense, lazy } from 'react';
+import { structureSource } from "../core/structureSource.js";
+import { StructurePlaceholder } from "./StructurePlaceholder.js";
+const StructureSvg = lazy(async () => {
+    const module = await import("./StructureSvg.js");
+    return { default: module.StructureSvg };
+});
+/**
+ * Draw a structure, from whichever notation the caller has.
+ *
+ * Nothing here throws and nothing renders a broken box: a blank value, a
+ * molfile with an empty atom block and a SMILES with a typo in it all come out
+ * as the same quiet placeholder, sized like the picture that would have been
+ * drawn so a list of structures keeps its rhythm. The box the renderers load
+ * into is that same placeholder, so nothing moves once they arrive.
+ * @param props - The structure, its size and what is written on it.
+ * @returns The picture, or the placeholder.
+ */
+export function Structure(props) {
+    const { idCode, coordinates, molfile, smiles, width = 200, height = 140, labels = {}, autoCrop = true, autoCropMargin = 4, atomHighlight, atomHighlightColor = '#a5d8ff', bondHighlight, bondHighlightColor = '#ffd8a8', fallback = '—', } = props;
+    const source = structureSource({ idCode, coordinates, molfile, smiles });
+    if (source.kind === 'empty') {
+        return (_jsx(StructurePlaceholder, { width: width, height: height, children: fallback }));
+    }
+    return (_jsx(Suspense, { fallback: _jsx(StructurePlaceholder, { width: width, height: height }), children: _jsx(StructureSvg, { source: source, width: width, height: height, autoCrop: autoCrop, autoCropMargin: autoCropMargin, atomHighlight: atomHighlight, atomHighlightColor: atomHighlightColor, bondHighlight: bondHighlight, bondHighlightColor: bondHighlightColor, showAtomNumber: labels.atoms ?? false, showBondNumber: labels.bonds ?? false, showMapping: labels.mapping ?? false, label: labels.caption, fallback: fallback }) }));
+}
+//# sourceMappingURL=Structure.js.map

package/lib/structure/ui/Structure.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Structure.js","sourceRoot":"","sources":["../../../src/structure/ui/Structure.tsx"],"names":[],"mappings":";AAWA,OAAO,EAAE,QAAQ,EAAE,IAAI,EAAE,MAAM,OAAO,CAAC;AAEvC,OAAO,EAAE,eAAe,EAAE,MAAM,4BAA4B,CAAC;AAE7D,OAAO,EAAE,oBAAoB,EAAE,MAAM,2BAA4B,CAAC;AAElE,MAAM,YAAY,GAAG,IAAI,CAAC,KAAK,IAAI,EAAE;IACnC,MAAM,MAAM,GAAG,MAAM,MAAM,CAAC,mBAAoB,CAAC,CAAC;IAClD,OAAO,EAAE,OAAO,EAAE,MAAM,CAAC,YAAY,EAAE,CAAC;AAC1C,CAAC,CAAC,CAAC;AAuGH;;;;;;;;;;GAUG;AACH,MAAM,UAAU,SAAS,CAAC,KAAqB;IAC7C,MAAM,EACJ,MAAM,EACN,WAAW,EACX,OAAO,EACP,MAAM,EACN,KAAK,GAAG,GAAG,EACX,MAAM,GAAG,GAAG,EACZ,MAAM,GAAG,EAAE,EACX,QAAQ,GAAG,IAAI,EACf,cAAc,GAAG,CAAC,EAClB,aAAa,EACb,kBAAkB,GAAG,SAAS,EAC9B,aAAa,EACb,kBAAkB,GAAG,SAAS,EAC9B,QAAQ,GAAG,GAAG,GACf,GAAG,KAAK,CAAC;IAEV,MAAM,MAAM,GAAG,eAAe,CAAC,EAAE,MAAM,EAAE,WAAW,EAAE,OAAO,EAAE,MAAM,EAAE,CAAC,CAAC;IAEzE,IAAI,MAAM,CAAC,IAAI,KAAK,OAAO,EAAE,CAAC;QAC5B,OAAO,CACL,KAAC,oBAAoB,IAAC,KAAK,EAAE,KAAK,EAAE,MAAM,EAAE,MAAM,YAC/C,QAAQ,GACY,CACxB,CAAC;IACJ,CAAC;IAED,OAAO,CACL,KAAC,QAAQ,IAAC,QAAQ,EAAE,KAAC,oBAAoB,IAAC,KAAK,EAAE,KAAK,EAAE,MAAM,EAAE,MAAM,GAAI,YACxE,KAAC,YAAY,IACX,MAAM,EAAE,MAAM,EACd,KAAK,EAAE,KAAK,EACZ,MAAM,EAAE,MAAM,EACd,QAAQ,EAAE,QAAQ,EAClB,cAAc,EAAE,cAAc,EAC9B,aAAa,EAAE,aAAa,EAC5B,kBAAkB,EAAE,kBAAkB,EACtC,aAAa,EAAE,aAAa,EAC5B,kBAAkB,EAAE,kBAAkB,EACtC,cAAc,EAAE,MAAM,CAAC,KAAK,IAAI,KAAK,EACrC,cAAc,EAAE,MAAM,CAAC,KAAK,IAAI,KAAK,EACrC,WAAW,EAAE,MAAM,CAAC,OAAO,IAAI,KAAK,EACpC,KAAK,EAAE,MAAM,CAAC,OAAO,EACrB,QAAQ,EAAE,QAAQ,GAClB,GACO,CACZ,CAAC;AACJ,CAAC"}

package/lib/structure/ui/StructureEditor.d.ts

@@ -0,0 +1,75 @@
+/**
+ * The canvas structure editor and the box it is drawn in.
+ *
+ * The canvas itself sits behind `React.lazy`: it is the half that imports
+ * react-ocl, so a page that never opens an editor never downloads openchemlib,
+ * and `react-cheminfo/structure` stays importable when those optional peers
+ * are absent.
+ */
+import type { CSSProperties, ReactElement } from 'react';
+import type { CanvasEditorInputFormat } from 'react-ocl';
+import type { StructureEditorChange, StructureEditorMode } from './EditorCanvas.tsx';
+export interface StructureEditorProps {
+    /**
+     * Called after every edit, once the drawing has been still for `debounce`
+     * milliseconds, with every notation read out of the editor.
+     */
+    onChange: (change: StructureEditorChange) => void;
+    /**
+     * Draw a query fragment rather than a whole structure, which is what a
+     * substructure filter needs.
+     * @default false
+     */
+    fragment?: boolean;
+    /**
+     * How `value` is written.
+     * @default 'idcode'
+     */
+    inputFormat?: CanvasEditorInputFormat;
+    /**
+     * What the canvas holds. Read once, when the editor appears and again on
+     * every change of `revision`: the editor is uncontrolled, so feeding the
+     * drawing back into it would replace the structure and reset every
+     * coordinate under the pen.
+     * @default ''
+     */
+    value?: string;
+    /**
+     * Bumped by the caller to load `value` into the canvas again, which is what
+     * an example, a share link or a Clear button does. Changing it discards
+     * whatever was being drawn.
+     * @default 0
+     */
+    revision?: number;
+    /**
+     * How long the drawing has to be still before `onChange` is called, in
+     * milliseconds. Long enough that drawing a ring does not publish six
+     * structures; `0` reports every stroke.
+     * @default 300
+     */
+    debounce?: number;
+    /**
+     * Smallest height of the drawing area, in pixels. Raised to whatever the
+     * toolbar needs, which is usually more.
+     * @default 320
+     */
+    minHeight?: number;
+    /**
+     * Whether the editor draws one structure or a reaction. A reaction canvas
+     * has its own toolbar and its own arrow.
+     * @default 'molecule'
+     */
+    mode?: StructureEditorMode;
+    /** Class the container carries, so a site can reach it from its stylesheet. */
+    className?: string;
+    /** Extra style for the container, merged over the packaged one. */
+    style?: CSSProperties;
+}
+/**
+ * The canvas structure editor, sized to fill its container and never to hide
+ * part of its toolbar.
+ * @param props - What to draw, when to reload it, and where to send it.
+ * @returns The editor.
+ */
+export declare function StructureEditor(props: StructureEditorProps): ReactElement;
+//# sourceMappingURL=StructureEditor.d.ts.map

package/lib/structure/ui/StructureEditor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"StructureEditor.d.ts","sourceRoot":"","sources":["../../../src/structure/ui/StructureEditor.tsx"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,KAAK,EAAE,aAAa,EAAE,YAAY,EAAE,MAAM,OAAO,CAAC;AAEzD,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,WAAW,CAAC;AAEzD,OAAO,KAAK,EACV,qBAAqB,EACrB,mBAAmB,EACpB,MAAM,oBAAoB,CAAC;AAQ5B,MAAM,WAAW,oBAAoB;IACnC;;;OAGG;IACH,QAAQ,EAAE,CAAC,MAAM,EAAE,qBAAqB,KAAK,IAAI,CAAC;IAClD;;;;OAIG;IACH,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB;;;OAGG;IACH,WAAW,CAAC,EAAE,uBAAuB,CAAC;IACtC;;;;;;OAMG;IACH,KAAK,CAAC,EAAE,MAAM,CAAC;IACf;;;;;OAKG;IACH,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB;;;;;OAKG;IACH,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB;;;;OAIG;IACH,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB;;;;OAIG;IACH,IAAI,CAAC,EAAE,mBAAmB,CAAC;IAC3B,+EAA+E;IAC/E,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,mEAAmE;IACnE,KAAK,CAAC,EAAE,aAAa,CAAC;CACvB;AAED;;;;;GAKG;AACH,wBAAgB,eAAe,CAAC,KAAK,EAAE,oBAAoB,GAAG,YAAY,CAmCzE"}

package/lib/structure/ui/StructureEditor.js

@@ -0,0 +1,83 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { Suspense, lazy, useCallback, useEffect, useRef } from 'react';
+import { useToolbarFloor } from "./useToolbarFloor.js";
+const EditorCanvas = lazy(async () => {
+    const module = await import("./EditorCanvas.js");
+    return { default: module.EditorCanvas };
+});
+/**
+ * The canvas structure editor, sized to fill its container and never to hide
+ * part of its toolbar.
+ * @param props - What to draw, when to reload it, and where to send it.
+ * @returns The editor.
+ */
+export function StructureEditor(props) {
+    const { onChange, fragment = false, inputFormat = 'idcode', value = '', revision = 0, debounce = 300, minHeight = 320, mode = 'molecule', className, style, } = props;
+    const containerRef = useToolbarFloor({ minHeight, revision });
+    const handleChange = useDebounced(onChange, debounce, revision);
+    return (_jsx("div", { ref: containerRef, className: className, style: { ...ROOT_STYLE, minHeight, ...style }, children: _jsx(Suspense, { fallback: _jsx("div", { style: LOADING_STYLE, children: "Loading the editor\u2026" }), children: _jsx(EditorCanvas, { onChange: handleChange, fragment: fragment, inputFormat: inputFormat, value: value, mode: mode }, revision) }) }));
+}
+/**
+ * Report the last edit of a burst rather than every one of them.
+ *
+ * The editor's own event is read out before the wait starts, so what arrives
+ * late is a plain object rather than a handle on an editor that has moved on.
+ * @param onChange - What the caller wants told.
+ * @param delay - How long the drawing has to be still, in milliseconds.
+ * @param resetKey - Dropped edits: a burst still waiting when the caller
+ * replaces the structure describes a canvas that no longer exists.
+ * @returns The handler to give the canvas.
+ */
+function useDebounced(onChange, delay, resetKey) {
+    const timerRef = useRef(null);
+    const onChangeRef = useRef(onChange);
+    useEffect(() => {
+        onChangeRef.current = onChange;
+    });
+    useEffect(() => {
+        return () => {
+            if (timerRef.current !== null) {
+                clearTimeout(timerRef.current);
+                timerRef.current = null;
+            }
+        };
+    }, [resetKey]);
+    return useCallback((change) => {
+        if (timerRef.current !== null)
+            clearTimeout(timerRef.current);
+        if (delay <= 0) {
+            onChangeRef.current(change);
+            return;
+        }
+        timerRef.current = setTimeout(() => {
+            timerRef.current = null;
+            onChangeRef.current(change);
+        }, delay);
+    }, [delay]);
+}
+/**
+ * The canvas is positioned out of the height computation, so the container's
+ * own height is what the measured toolbar floor writes on it. The `minHeight`
+ * prop is applied on top of this at first render: without a height before the
+ * toolbar has been measured, the editor is built at zero size and never paints
+ * the structure it was given.
+ */
+const ROOT_STYLE = {
+    position: 'relative',
+    overflow: 'hidden',
+    boxSizing: 'border-box',
+    border: '1px solid #d3d8de',
+    borderRadius: 6,
+    background: '#fff',
+};
+/** The box the canvas will fill, so its arrival moves nothing. */
+const LOADING_STYLE = {
+    position: 'absolute',
+    inset: 0,
+    display: 'flex',
+    alignItems: 'center',
+    justifyContent: 'center',
+    color: '#8a96a3',
+    fontSize: 13,
+};
+//# sourceMappingURL=StructureEditor.js.map

package/lib/structure/ui/StructureEditor.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"StructureEditor.js","sourceRoot":"","sources":["../../../src/structure/ui/StructureEditor.tsx"],"names":[],"mappings":"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"}