2.2.0

dist/declarations/loader/parser-loader.d.ts

@@ -3,6 +3,7 @@
  * @author Alexander Rose <[email protected]>
  * @private
  */
+import type { InferBondsOptions } from '../structure/structure-utils';
 import Loader from './loader';
 import { LoaderParameters, LoaderInput } from './loader-utils';
 export interface ParserParams {
@@ -15,6 +16,7 @@ export interface ParserParams {
     delimiter?: string;
     comment?: string;
     columnNames?: string;
+    inferBonds?: InferBondsOptions;
 }
 /**
  * Parser loader class

dist/declarations/ngl.d.ts

@@ -3,7 +3,6 @@
  * @private
  * @author Alexander Rose <[email protected]>
  */
-import './polyfills';
 /**
  * The NGL module. These members are available in the `NGL` namespace when using the {@link https://github.com/umdjs/umd|UMD} build in the `ngl.js` file.
  * @module NGL

dist/declarations/parser/pdb-parser.d.ts

@@ -4,22 +4,29 @@
  * @private
  */
 import StructureParser from './structure-parser';
+import { InferBondsOptions } from '../structure/structure-utils';
 import Streamer from '../streamer/streamer';
 import { ParserParameters } from './parser';
 declare const HelixTypes: {
     [k: number]: string;
 };
 export interface PdbParserParameters extends ParserParameters {
     hex: boolean;
+    inferBonds: InferBondsOptions;
 }
 declare class PdbParser extends StructureParser {
+    hex: boolean;
+    inferBonds: InferBondsOptions;
     /**
      * Create a pdb parser
      * @param  {Streamer} streamer - streamer object
      * @param  {Object} params - params object
      * @param  {Boolean} params.hex - hexadecimal parsing of
      *                                atom numbers >99.999 and
      *                                residue numbers >9.999
+     * @param  {InferBondsOptions} params.inferBonds: 'all': use explicit bonds and detect by distance
+     *                                               'auto': If a hetgroup residue has explicit bonds, don't auto-detect
+     *                                               'none': Don't add any bonds automatically
      * @return {undefined}
      */
     constructor(streamer: Streamer, params?: Partial<PdbParserParameters>);

dist/declarations/parser/structure-parser.d.ts

@@ -4,13 +4,15 @@
  * @private
  */
 import Parser, { ParserParameters } from './parser';
+import StructureBuilder from '../structure/structure-builder';
 import Streamer from '../streamer/streamer';
 export interface StructureParserParameters extends ParserParameters {
     firstModelOnly: boolean;
     asTrajectory: boolean;
     cAlphaOnly: boolean;
 }
 declare class StructureParser extends Parser {
+    structureBuilder: StructureBuilder;
     constructor(streamer: Streamer, params?: Partial<StructureParserParameters>);
     get type(): string;
     get __objName(): string;

dist/declarations/structure/structure-utils.d.ts

@@ -21,7 +21,13 @@ export declare function getChainname(index: number): string;
  * chemical type (e.g. water molecules) are grouped into the same chain.
  **/
 export declare function calculateChainnames(structure: Structure, useExistingBonds?: boolean): void;
-export declare function calculateBonds(structure: Structure): void;
+export declare function calculateBonds(structure: Structure, inferBonds?: InferBondsOptions): void;
+/**
+ * Should Bonds be inferred for `all` atoms, `none` or `auto`
+ * If `auto`, any hetgroup residue with at least one CONECT record will
+ * not have bonding inferred, and will rely on the CONECT records
+ */
+export declare type InferBondsOptions = 'all' | 'none' | 'auto';
 export interface ResidueBonds {
     atomIndices1: number[];
     atomIndices2: number[];
@@ -33,7 +39,7 @@ export declare function calculateResidueBonds(r: ResidueProxy): {
     bondOrders: number[];
 };
 export declare function calculateAtomBondMap(structure: Structure): number[][];
-export declare function calculateBondsWithin(structure: Structure, onlyAddRung?: boolean): void;
+export declare function calculateBondsWithin(structure: Structure, onlyAddRung?: boolean, inferBonds?: InferBondsOptions): void;
 export declare function calculateBondsBetween(structure: Structure, onlyAddBackbone?: boolean, useExistingBonds?: boolean): void;
 export declare function buildUnitcellAssembly(structure: Structure): void;
 export declare function guessElement(atomName: string): string;

package.json

@@ -1,6 +1,6 @@
 {
   "name": "ngl",
-  "version": "2.1.1",
+  "version": "2.2.0",
   "description": "Scalable molecular graphics for the web",
   "main": "dist/ngl.umd.js",
   "module": "dist/ngl.esm.js",