0.4.5

.eslintignore

@@ -1,3 +0,0 @@
-node_modules/*
-build/*
-lib/*

.eslintrc.json

@@ -1,120 +0,0 @@
-{
-    "env": {
-        "browser": true,
-        "node": true
-    },
-    "parserOptions": {
-        "ecmaVersion": 2018,
-        "sourceType": "module",
-        "ecmaFeatures": {
-            "impliedStrict": true
-        }
-    },
-    "rules": {
-        "indent": "off",
-        "arrow-parens": [
-            "off",
-            "as-needed"
-        ],
-        "brace-style": "off",
-        "comma-spacing": "off",
-        "space-infix-ops": "error",
-        "comma-dangle": "off",
-        "eqeqeq": [
-            "error",
-            "smart"
-        ],
-        "import/order": "off",
-        "no-eval": "warn",
-        "no-new-wrappers": "warn",
-        "no-trailing-spaces": "error",
-        "no-unsafe-finally": "warn",
-        "no-var": "error",
-        "spaced-comment": "error",
-        "semi": "warn",
-        "no-restricted-syntax": [
-            "error",
-            {
-                "selector": "ExportDefaultDeclaration",
-                "message": "Default exports are not allowed"
-            }
-        ],
-        "no-throw-literal": "error",
-        "key-spacing": "error",
-        "object-curly-spacing": ["error", "always"],
-        "array-bracket-spacing": "error",
-        "space-in-parens": "error",
-        "computed-property-spacing": "error",
-        "prefer-const": ["error", {
-            "destructuring": "all",
-            "ignoreReadBeforeAssign": false
-        }],
-        "space-before-function-paren": "off",
-        "func-call-spacing": "off",
-        "no-multi-spaces": "error",
-        "block-spacing": "error",
-        "keyword-spacing": "off",
-        "space-before-blocks": "error",
-        "semi-spacing": "error"
-    },
-    "overrides": [
-        {
-            "files": ["**/*.ts", "**/*.tsx"],
-            "parser": "@typescript-eslint/parser",
-            "parserOptions": {
-                "project": ["tsconfig.json", "tsconfig.commonjs.json"],
-                "sourceType": "module"
-            },
-            "plugins": [
-                "@typescript-eslint"
-            ],
-            "rules": {
-                "@typescript-eslint/ban-types": "off",
-                "@typescript-eslint/class-name-casing": "off",
-                "@typescript-eslint/indent": [
-                    "error",
-                    4
-                ],
-                "@typescript-eslint/member-delimiter-style": [
-                    "off",
-                    {
-                        "multiline": {
-                            "delimiter": "none",
-                            "requireLast": true
-                        },
-                        "singleline": {
-                            "delimiter": "semi",
-                            "requireLast": false
-                        }
-                    }
-                ],
-                "@typescript-eslint/prefer-namespace-keyword": "warn",
-                "@typescript-eslint/quotes": [
-                    "error",
-                    "single",
-                    {
-                        "avoidEscape": true,
-                        "allowTemplateLiterals": true
-                    }
-                ],
-                "@typescript-eslint/semi": [
-                    "off",
-                    null
-                ],
-                "@typescript-eslint/type-annotation-spacing": "error",
-                "@typescript-eslint/brace-style": [
-                    "error",
-                    "1tbs", { "allowSingleLine": true }
-                ],
-                "@typescript-eslint/comma-spacing": "error",
-                "@typescript-eslint/space-before-function-paren": ["error", {
-                    "anonymous": "always",
-                    "named": "never",
-                    "asyncArrow": "always"
-                }],
-                "@typescript-eslint/func-call-spacing": ["error"],
-                "@typescript-eslint/keyword-spacing": ["error"]
-            }
-        }
-    ]
-}

.github/pull_request_template.md

@@ -1,10 +0,0 @@
-<!-- Thank you for contributing to Mol* -->
-
-# Description
-
-
-## Actions
-
-- [ ] Added description of changes to the `[Unreleased]` section of `CHANGELOG.md`
-- [ ] Updated headers of modified files
-- [ ] Added my name to `package.json`'s `contributors`

.github/workflows/node.yml

@@ -1,20 +0,0 @@
-on:
-  push:
-  pull_request:
-
-jobs:
-  build:
-    runs-on: ubuntu-latest
-    steps:
-    - uses: actions/checkout@v2
-    - uses: actions/setup-node@v2
-      with:
-        node-version: 16
-    - run: npm ci
-    - run: sudo apt-get install xvfb
-    - name: Lint
-      run: npm run lint
-    - name: Test
-      run: npm install --no-save "gl@^5.0.0" && xvfb-run --auto-servernum npm run jest
-    - name: Build
-      run: npm run build

.gitignore

@@ -5,9 +5,6 @@ node_modules/
 debug.log
 npm-debug.log
 tsconfig.tsbuildinfo
-tsconfig.commonjs.tsbuildinfo
 
 *.sublime-workspace
 .idea
-
-.DS_Store

.npmignore

@@ -1,5 +0,0 @@
-tests
-perf-tests
-_spec
-*.tsbuildinfo
-*.js.map

.travis.yml

@@ -14,5 +14,6 @@ before_install:
 node_js:
   - "12"
   - "10"
+  - "8"
 before_script:
   - export DISPLAY=:99.0; sh -e /etc/init.d/xvfb start

.vscode/extensions.json

@@ -4,8 +4,9 @@
 
 	// List of extensions which should be recommended for users of this workspace.
 	"recommendations": [
-		"dbaeumer.vscode-eslint",
 		"firsttris.vscode-jest-runner",
+		"ms-vscode.vscode-typescript-tslint-plugin",
+		"msjsdiag.debugger-for-chrome",
 		"slevesque.shader",
 		"stpn.vscode-graphql",
 		"wayou.vscode-todo-highlight"

.vscode/settings.json

@@ -6,9 +6,4 @@
         "*.vert.ts": "glsl",
         "*.gql.ts": "graphql"
     },
-    "eslint.options": {
-        "overrideConfig": {
-            "ignorePatterns": ["webpack.config.js", "scripts/*"],
-        },
-    }
 }

.vscode/tasks.json

@@ -9,20 +9,6 @@
             "problemMatcher": [
                 "$tsc"
             ]
-        },
-        {
-            "type": "npm",
-            "script": "build-tsc",
-            "problemMatcher": [
-                "$tsc"
-            ]
-        },
-        {
-            "type": "npm",
-            "script": "watch",
-            "problemMatcher": [
-                "$tsc"
-            ]
         }
     ]
 }

CHANGELOG.md

@@ -1,653 +0,0 @@
-# Change Log
-All notable changes to this project will be documented in this file, following the suggestions of [Keep a CHANGELOG](http://keepachangelog.com/). This project adheres to [Semantic Versioning](http://semver.org/) for its most widely used - and defacto - public interfaces.
-
-Note that since we don't clearly distinguish between a public and private interfaces there will be changes in non-major versions that are potentially breaking. If we make breaking changes to less used interfaces we will highlight it in here.
-
-
-## [Unreleased]
-
-- Make `PluginContext.initContainer` checkered canvas background optional
-
-## [v3.23.0] - 2022-10-19
-
-- Add `PluginContext.initContainer/mount/unmount` methods; these should make it easier to reuse a plugin context with both custom and built-in UI
-- Add `PluginContext.canvas3dInitialized`
-- `createPluginUI` now resolves after the 3d canvas has been initialized
-- Change EM Volume Streaming default from `Whote Structure` to `Auto`
-
-## [v3.22.0] - 2022-10-17
-
-- Replace `VolumeIsosurfaceParams.pickingGranularity` param with `Volume.PickingGranuality` 
-
-## [v3.21.0] - 2022-10-17
-
-- Add `VolumeIsosurfaceParams.pickingGranularity` param
-- Prevent component controls collapsing when option is selected
-
-## [v3.20.0] - 2022-10-16
-
-- [Breaking] Rename the ``model-index`` color theme to ``trajectory-index``
-- Add a new ``model-index`` color theme that uniquely colors each loaded model
-- Add the new ``model-index`` and ``structure-index`` color themes as an option for the carbon color in the ``element-symbol`` and ``ilustrative`` color themes
-- Add ``structure-index`` color theme that uniquely colors each root structure
-- Add ``nearest`` method to ``Lookup3D``
-- Add mipmap-based blur for skybox backgrounds
-
-## [v3.19.0] - 2022-10-01
-
-- Fix "empty textures" error on empty canvas
-- Optimize BinaryCIF integer packing encoder
-- Fix dual depth peeling when post-processing is off or when rendering direct-volumes
-- Add ``cameraClipping.minNear`` parameter
-- Fix black artifacts on specular highlights with transparent background
-
-## [v3.18.0] - 2022-09-17
-
-- Integration of Dual depth peeling - OIT method
-- Stereo camera improvements
-    - Fix param updates not applied
-    - Better param ranges and description
-    - Add timer.mark for left/right camera
-
-## [v3.17.0] - 2022-09-11
-
-- [Fix] Clone ``Canvas3DParams`` when creating a ``Canvas3D`` instance to prevent shared state between multiple instances
-- Add ``includeResidueTest`` option to ``alignAndSuperposeWithSIFTSMapping``
-- Add ``parentDisplay`` param for interactions representation.
-- [Experimental] Add support for PyMOL, VMD, and Jmol atom expressions in selection scripts
-- Support for ``failIfMajorPerformanceCaveat`` webgl attribute. Add ``PluginConfig.General.AllowMajorPerformanceCaveat`` and ``allow-major-performance-caveat`` Viewer GET param.
-- Fix handling of PDB TER records (#549)
-- Add support for getting multiple loci from a representation (``.getAllLoci()``)
-- Add ``key`` property to intra- and inter-bonds for referencing source data
-- Fix click event triggered after move
-
-## [v3.16.0] - 2022-08-25
-
-- Support ``globalColorParams`` and ``globalSymmetryParams`` in common representation params
-- Support ``label`` parameter in ``Viewer.loadStructureFromUrl``
-- Fix ``ViewportHelpContent`` Mouse Controls section
-
-## [v3.15.0] - 2022-08-23
-
-- Fix wboit in Safari >=15 (add missing depth renderbuffer to wboit pass)
-- Add 'Around Camera' option to Volume streaming
-- Avoid queuing more than one update in Volume streaming
-
-## [v3.14.0] - 2022-08-20
-
-- Expose inter-bonds compute params in structure
-- Improve performance of inter/intra-bonds compute
-- Fix defaultAttribs handling in Canvas3DContext.fromCanvas
-- Confal pyramids extension improvements
-    - Add custom labels to Confal pyramids
-    - Improve naming of some internal types in Confal pyramids extension coordinate
-    - Add example mmCIF file with categories necessary to display Confal pyramids
-    - Change the lookup logic of NtC steps from residues
-- Add support for download of gzipped files
-- Don't filter IndexPairBonds by element-based rules in MOL/SDF and MOL2 (without symmetry) models
-- Fix Glycam Saccharide Names used by default
-- Fix GPU surfaces rendering in Safari with WebGL2
-- Add ``fov`` (Field of View) Canvas3D parameter
-- Add ``sceneRadiusFactor`` Canvas3D parameter
-- Add background pass (skybox, image, horizontal/radial gradient)
-    - Set simple-settings presets via ``PluginConfig.Background.Styles``
-    - Example presets in new backgrounds extension
-    - Load skybox/image from URL or File (saved in session)
-    - Opacity, saturation, lightness controls for skybox/image
-    - Coverage (viewport or canvas) controls for image/gradient
-- [Breaking] ``AssetManager`` needs to be passed to various graphics related classes
-- Fix SSAO renderable initialization
-- Reduce number of webgl state changes
-    - Add ``viewport`` and ``scissor`` to state object
-    - Add ``hasOpaque`` to scene object
-- Handle edge cases where some renderables would not get (correctly) rendered
-    - Fix text background rendering for opaque text
-    - Fix helper scenes not shown when rendering directly to draw target
-- Fix ``CustomElementProperty`` coloring not working
-
-## [v3.13.0] - 2022-07-24
-
-- Fix: only update camera state if manualReset is off (#494)
-- Improve handling principal axes of points in a plane
-- Add 'material' annotation support for textures
-- More effort to avoid using ``flat`` qualifier in shaders: add ``dVaryingGroup``
-- Enable ``immediateUpdate`` for iso level in isosurface and volume streaming controls
-- Add support to download CCD from configurable URL
-
-## [v3.12.1] - 2022-07-20
-
-- Fix plugin behavior dispose logic to correctly unsubscribe observables.
-
-## [v3.12.0] - 2022-07-17
-
-- Add ``colorMarker`` option to Renderer. This disables the highlight and select marker at a shader level for faster rendering of large scenes in some cases.
-- Bind shared textures only once per pass, not for each render item
-- Fix missing 'material' annotation for some uniforms, causing unnecessary uniform updates
-- Remove use of ``isnan`` in impostor shaders, not needed and causing slowdown
-- Avoid using ``flat`` qualifier in shaders, causing slowdown
-- Improve CellPack's ``adjustStyle`` option (disable ``colorMarker``, set component options, enable marking w/o ghost)
-- Scan all entities when looking for ``struct_conn`` entries (fixes issue when the same ``label_asym_id`` is used in more than one entity)
-
-## [v3.11.0] - 2022-07-04
-
-- Add ``instanceGranularity`` option for marker, transparency, clipping, overpaint, substance data to save memory
-- CellPack extension tweaks
-    - Use instancing to create DNA/RNA curves to save memory
-    - Enable ``instanceGranularity`` by default
-    - Add ``adjustStyle`` option to LoadCellPackModel action (stylized, no multi-sample, no far clipping, chain picking)
-- Structure Superposition now respects pivot's coordinate system
-
-## [v3.10.2] - 2022-06-26
-
-- Fix superfluous shader varying
-- Improve use of gl_VertexID when possible
-
-## [v3.10.1] - 2022-06-26
-
-- Fix groupCount when updating TextureMesh-based visuals
-
-## [v3.10.0] - 2022-06-24
-
-- Add support for Glycam saccharide names
-- Add ``PluginConfig.Viewport.ShowTrajectoryControls`` config option
-
-## [v3.9.1] - 2022-06-19
-
-- Fix missing ``super.componentWillUnmount()`` calls (@simeonborko)
-- Fix missing ``uGroupCount`` update for visuals
-- Fix missing aromatic bond display
-
-## [v3.9.0] - 2022-05-30
-
-- Improve picking by using drawbuffers (when available) to reduce number of drawcalls
-- GPU timing support
-    - Add ``timing-mode`` Viewer GET param
-    - Add support for webgl timer queries
-    - Add timer marks around GPU render & compute operations
-- Volume Server CIF: Add check that a data block contains volume data before parsing
-- Fix ``Scene.clear`` not clearing primitives & volumes arrays (@JonStargaryen)
-- Fix rendering volumes when wboit is switched off and postprocessing is enabled
-
-## [v3.8.2] - 2022-05-22
-
-- Fix ``Scene.opacityAverage`` not taking xray shaded into account
-
-## [v3.8.1] - 2022-05-14
-
-- Fix issues with marking camera/handle helper (#433)
-- Fix issues with array uniforms when running with headless-gl
-- Fix Polymer Chain Instance coloring
-- Improve performance of scene marker/opacity average calculation
-
-## [v3.8.0] - 2022-04-30
-
-- Add support for outlines around transparent objects
-- Improve per-group transparency when wboit is switched off
-- Improve ``ColorTheme`` typing with ``ColorType`` generic.
-    - Defaults to ``ColorTypeLocation``
-    - Set when using ``ColorTypeDirect`` or ``ColorTypeGrid``
-- Fix case handling of ``struct_conf`` mmCIF enumeration field (#425)
-- Fix ``allowTransparentBackfaces`` for per-group transparency
-- Fix ``FormatRegistry.isApplicable`` returning true for unregistered formats
-- Fix: handle building of ``GridLookup3D`` with zero cell size
-- Fix ``ignoreLight`` for direct-volume rendering with webgl1
-- Fix (non-black) outlines when using transparent background
-
-## [v3.7.0] - 2022-04-13
-
-- Fix ``xrayShaded`` for texture-mesh geometries
-- [Breaking] Change ``allowTransparentBackfaces`` to ``transparentBackfaces`` with options ``off``, ``on``, ``opaque``. This was only added in 3.6.0, so allowing a breaking change here.
-    - ``off``: don't show (default)
-    - ``on``: show with transparency
-    - ``opaque``: show fully opaque
-- Add option to disable file drop overlay.
-
-## [v3.6.2] - 2022-04-05
-
-- ModelServer ligand queries: fixes for alternate locations, additional atoms & UNL ligand
-- React 18 friendly ``useBehavior`` hook.
-
-## [v3.6.1] - 2022-04-03
-
-- Fix React18 related UI regressions.
-
-## [v3.6.0] - 2022-04-03
-
-- Check that model and coordinates have same element count when creating a trajectory
-- Fix aromatic rings assignment: do not mix flags and planarity test
-- Improve bonds assignment of coarse grained models: check for IndexPairBonds and exhaustive StructConn
-- Fix unit mapping in bondedAtomicPairs MolScript query
-- Improve pdb parsing: handle non unique atom and chain names (fixes #156)
-- Fix volume streaming for entries with multiple contour lists
-- Add ``allowTransparentBackfaces`` parameter to support double-sided rendering of transparent geometries
-- Fix handling of case insensitive mmCIF enumeration fields (including entity.type)
-- Fix ``disable-wboit`` Viewer GET param
-- Add support for React 18.
-    - Used by importing ``createPluginUI`` from ``mol-plugin-ui/react18``;
-    - In Mol* 4.0, React 18 will become the default option.
-
-## [v3.5.0] - 2022-03-25
-
-- Fix issues with bounding-sphere & color-smoothing (mostly for small geometries)
-- Support BCIF => CIF conversion in ``cif2bcif`` CLI tool
-
-## [v3.4.0] - 2022-03-13
-
-- Fix handling of mmcif with empty ``label_*`` fields
-- Improve saccharide detection (compare against list from CCD)
-- Fix legend label of hydrophobicity color theme
-- Add ``LoadTrajectory`` action
-- Add ``CustomImportControls`` to left panel
-- Add Zenodo import extension (load structures, trajectories, volumes, and zip files)
-- Fix loading of some compressed files within sessions
-- Fix wrong element assignment for atoms with Charmm ion names
-- Fix handling of empty symmetry cell data
-- Add support for ``trr`` and ``nctraj`` coordinates files
-- Add support for ``prmtop`` and ``top`` topology files
-
-## [v3.3.1] - 2022-02-27
-
-- Fix issue with unit boundary reuse (do at visual level instead)
-- Add option to ignore ions for inter-unit bond computation
-
-## [v3.3.0] - 2022-02-27
-
-- Fix parsing contour-level from emdb v3 header files
-- Fix invalid CSS (#376)
-- Fix "texture not renderable" & "texture not bound" warnings (#319)
-- Fix visual for bonds between two aromatic rings
-- Fix visual for delocalized bonds (parsed from mmcif and mol2)
-- Fix ring computation algorithm
-- Add ``UnitResonance`` property with info about delocalized triplets
-- Resolve marking in main renderer loop to improve overall performance
-- Use ``throttleTime`` instead of ``debounceTime`` in sequence viewer for better responsiveness
-- Change line geometry default ``scaleFactor`` to 2 (3 is too big after fixing line rendering)
-- Trajectory animation performance improvements
-    - Reuse ``Model.CoarseGrained`` for coordinate trajectories
-    - Avoid calculating ``InterUnitBonds`` when ``Structure.parent`` ones are empty
-    - Reuse unit boundary if sphere has not changed too much
-    - Don't show 'inter-bond' and 'element-cross' visuals in line representations of polymerAndLigand preset
-- Fix additional mononucleotides detected as polymer components
-- Fix and improve ``canRemap`` handling in ``IntraUnitBonds``
-- Reuse occlusion for secondary passes during multi-sampling
-- Check if marking passes are needed before doing them
-- Add ``resolutionScale`` parameter to allow trading quality of occlusion for performance
-
-## [v3.2.0] - 2022-02-17
-
-- Rename "best database mapping" to "SIFTS Mapping"
-- Add schema and export support for ``atom_site.pdbx_sifts_xref_*`` fields
-- Add schema export support for ``atom_site.pdbx_label_index`` field
-- Add `traceOnly` parameter to chain/UniProt-based structure alignment
-- Store ``IndexPairBonds`` as a dynamic property.
-
-## [v3.1.0] - 2022-02-06
-
-- Fix ``xrayShaded`` & ``ignoreLight`` params not working at the same time
-- Add ``ignoreLight`` to component params
-- Tweaks for cleaner default representation style
-    - Cartoon: use ``nucleotide-ring`` instead of ``nucleotide-block``
-    - Focus: use ``xrayShaded`` instead of opacity; adjust target size; don't show non-covalent interactions twice
-- Fix representation preset side effects (changing post-processing parameters, see #363)
-- Add Quick Styles panel (default, illustrative, stylized)
-- Fix exported structure missing secondary-structure categories (#364)
-- Fix volume streaming error message: distinguish between missing data and server error (#364)
-
-## [v3.0.2] - 2022-01-30
-
-- Fix color smoothing of elongated structures (by fixing ``Sphere.expand`` for spheres with highly directional extrema)
-- Fix entity label not displayed when multiple instances of the same entity are highlighted
-- Fix empty elements created in ``StructureElement.Loci.extendToAllInstances``
-- Measurement options tweaks (allow larger ``textSize``; make ``customText`` essential)
-- Fix visual visibility sync edge case when changing state snapshots
-
-## [v3.0.1] - 2022-01-27
-
-- Fix marking pass not working with ``transparentBackground``
-- Fix pdbe xray maps url not https
-- Fix entity-id color theme broken for non-IHM models
-- Improve/fix marking of ``InteractionsInterUnitVisual`` (mark when all contact-feature members are given)
-- Add missing "entity-id" and "enity-source" options for carbon coloring to "element-symbol" color theme
-- Fix VolumeServer/query CLI
-- Support automatic iso-value adjustment for VolumeServer data in ``Viewer.loadVolumeFromUrl``
-- Emit drag event whenever started within viewport (not only for non-empty loci)
-
-## [v3.0.0] - 2022-01-23
-
-- Assembly handling tweaks:
-    - Do not include suffix for "identity assembly operators"
-    - Do not include assembly-related categories to export if the structure was composed from an assembly
-    - Special case for ``structAsymMap`` if Mol* asym id operator mapping is present
-- Support for opening ZIP files with multiple entries
-- Add Model Export extension
-- Bugfix: Automatically treat empty string as "non-present" value in BinaryCIF writer.
-- Fix coarse model support in entity-id color theme
-- Fix marking of carbohydrate visuals (whole chain could get marked instead of single residue)
-- Add custom colors to "element-symbol", "molecule-type", "residue-name", and "secondary-structure" themes
-- Support/bugfixes for ``atom_site.pdbx_sifts_xref`` categories
-- Improve/fix marking of ``InteractionsIntraUnitVisual`` (mark when all contact-feature members are given)
-
-## [v3.0.0-dev.10] - 2022-01-17
-
-- Fix ``getOperatorsForIndex``
-- Pass animation info (current frame & count) to state animations
-    - Fix camera stutter for "camera spin" animation
-- Add formal charge parsing support for MOL/SDF files (thanks @ptourlas)
-- [Breaking] Cleaner looking ``MembraneOrientationVisuals`` defaults
-- [Breaking] Add rock animation to trackball controls
-    - Add ``animate`` to ``TrackballControlsParams``, remove ``spin`` and ``spinSpeed``
-    - Add ``animate`` to ``SimpleSettingsParams``, remove ``spin``
-- Add "camera rock" state animation
-- Add support for custom colors to "molecule-type" theme
-- [Breaking] Add style parameter to "illustrative" color theme
-    - Defaults to "entity-id" style instead of "chain-id"
-- Add "illustrative" representation preset
-
-## [v3.0.0-dev.9] - 2022-01-09
-
-- Add PDBj as a ``pdb-provider`` option
-- Move Viewer APP to a separate file to allow use without importing light theme & index.html
-- Add symmetry support for mol2 files (only spacegroup setting 1)
-- Fix mol2 files element symbol assignment
-- Improve bond assignment from ``IndexPairBonds``
-    - Add ``key`` field for mapping to source data
-    - Fix assignment of bonds with unphysical length
-- Fix label/stats of single atom selection in multi-chain units
-
-## [v3.0.0-dev.8] - 2021-12-31
-
-- Add ``PluginFeatureDetection`` and disable WBOIT in Safari 15.
-- Add ``disable-wboit`` Viewer GET param
-- Add ``prefer-webgl1`` Viewer GET param
-- [Breaking] Refactor direct-volume rendering
-    - Remove isosurface render-mode (use GPU MC instead)
-    - Move coloring into theme (like for other geometries/renderables)
-        - Add ``direct`` color type
-        - Remove color from transfer-function (now only alpha)
-        - Add direct-volume color theme support
-        - Add volume-value color theme
-- [Breaking] Use size theme in molecular/gaussian surface & label representations
-    - This is breaking because it was hardcoded to ``physical`` internally but the repr size theme default was ``uniform`` (now ``physical``)
-
-## [v3.0.0-dev.7] - 2021-12-20
-
-- Reduce number of created programs/shaders
-    - Support specifying variants when creating graphics render-items
-    - Change double-side shader param from define to uniform
-    - Remove dMarkerType shader define (use uMarker as needed)
-    - Support to ignore defines depending on the shader variant
-    - Combine pickObject/pickInstance/pickGroup shader variants into one
-    - Combine markingDepth/markingMask shader variants into one
-    - Correctly set shader define flags for overpaint, transparency, substance, clipping
-- [Breaking] Add per-object clip rendering properties (variant/objects)
-    - ``SimpleSettingsParams.clipping.variant/objects`` and ``RendererParams.clip`` were removed
-
-## [v3.0.0-dev.6] - 2021-12-19
-
-- Enable temporal multi-sampling by default
-    - Fix flickering during marking with camera at rest
-- Enable ``aromaticBonds`` in structure representations by default
-- Add ``PluginConfig.Structure.DefaultRepresentationPreset``
-- Add ModelArchive support
-    - schema extensions (e.g., AlphaFold uses it for the pLDDT score)
-    - ModelArchive option in DownloadStructure action
-    - ``model-archive`` GET parameter for Viewer app
-    - ``Viewer.loadModelArchive`` method
-- Improve support for loading AlphaFold structures
-    - Automatic coloring by pLDDT
-    - AlphaFold DB option in DownloadStructure action
-    - ``afdb`` GET parameter for Viewer app
-    - ``Viewer.loadAlphaFoldDb`` method
-- Add QualityAssessment extension (using data from ma_qa_metric_local mmcif category)
-    - pLDDT & qmean score: coloring, repr presets, molql symbol, loci labels (including avg for mutli-residue selections)
-    - pLDDT: selection query
-- Warn about erroneous symmetry operator matrix (instead of throwing an error)
-- Added ``createPluginUI`` to ``mol-plugin-ui``
-    - Support ``onBeforeUIRender`` to make sure initial UI works with custom presets and similar features.
-- [Breaking] Removed ``createPlugin`` and ``createPluginAsync`` from ``mol-plugin-ui``
-    - Please use ``createPluginUI`` instead
-- Improve aromatic bonds handling
-    - Don't detect aromatic bonds for rings < 5 atoms based on planarity
-    - Prefer atoms in aromatic rings as bond reference positions
-
-## [v3.0.0-dev.5] - 2021-12-16
-
-- Fix initial camera reset not triggering for some entries.
-
-## [v3.0.0-dev.4] - 2021-12-14
-
-- Add ``bumpiness`` (per-object and per-group), ``bumpFrequency`` & ``bumpAmplitude`` (per-object) render parameters (#299)
-- Change ``label`` representation defaults: Use text border instead of rectangle background
-- Add outline color option to renderer
-- Fix false positives in Model.isFromPdbArchive
-- Add drag and drop support for loading any file, including multiple at once
-    - If there are session files (.molx or .molj) among the dropped files, only the first session will be loaded
-- Add drag and drop overlay
-- Safari 15.1 - 15.3 WebGL 2 support workaround
-- [Breaking] Move ``react`` and ``react-dom`` to ``peerDependencies``. This might break some builds.
-
-## [v3.0.0-dev.3] - 2021-12-4
-
-- Fix OBJ and USDZ export
-
-## [v3.0.0-dev.2] - 2021-12-1
-
-- Do not include tests and source maps in NPM package
-
-## [v3.0.0-dev.0] - 2021-11-28
-
-- Add multiple lights support (with color, intensity, and direction parameters)
-- [Breaking] Add per-object material rendering properties
-    - ``SimpleSettingsParams.lighting.renderStyle`` and ``RendererParams.style`` were removed
-- Add substance theme with per-group material rendering properties
-- ``StructureComponentManager.Options`` state saving support
-- ``ParamDefinition.Group.presets`` support
-
-## [v2.4.1] - 2021-11-28
-
-- Fix: allow atoms in aromatic rings to do hydrogen bonds
-
-## [v2.4.0] - 2021-11-25
-
-- Fix secondary-structure property handling
-    - StructureElement.Property was incorrectly resolving type & key
-    - StructureSelectionQuery helpers 'helix' & 'beta' were not ensuring property availability
-- Re-enable VAO with better workaround (bind null elements buffer before deleting)
-- Add ``Representation.geometryVersion`` (increments whenever the geometry of any of its visuals changes)
-- Add support for grid-based smoothing of Overpaint and Transparency visual state for surfaces
-
-## [v2.3.9] - 2021-11-20
-
-- Workaround: switch off VAO support for now
-
-## [v2.3.8] - 2021-11-20
-
-- Fix double canvas context creation (in plugin context)
-- Fix unused vertex attribute handling (track which are used, disable the rest)
-- Workaround for VAO issue in Chrome 96 (can cause WebGL to crash on geometry updates)
-
-## [v2.3.7] - 2021-11-15
-
-- Added ``ViewerOptions.collapseRightPanel``
-- Added ``Viewer.loadTrajectory`` to support loading "composed" trajectories (e.g. from gro + xtc)
-- Fix: handle parent in Structure.remapModel
-- Add ``rounded`` and ``square`` helix profile options to Cartoon representation (in addition to the default ``elliptical``)
-
-## [v2.3.6] - 2021-11-8
-
-- Add additional measurement controls: orientation (box, axes, ellipsoid) & plane (best fit)
-- Improve aromatic bond visuals (add ``aromaticScale``, ``aromaticSpacing``, ``aromaticDashCount`` params)
-- [Breaking] Change ``adjustCylinderLength`` default to ``false`` (set to true for focus representation)
-- Fix marker highlight color overriding select color
-- CellPack extension update
-    - add binary model support
-    - add compartment (including membrane) geometry support
-    - add latest mycoplasma model example
-- Prefer WebGL1 in Safari 15.1.
-
-## [v2.3.5] - 2021-10-19
-
-- Fix sequence viewer for PDB files with COMPND record and multichain entities.
-- Fix index pair bonds order assignment
-
-## [v2.3.4] - 2021-10-12
-
-- Fix pickScale not taken into account in line/point shader
-- Add pixel-scale, pick-scale & pick-padding GET params to Viewer app
-- Fix selecting bonds not adding their atoms in selection manager
-- Add ``preferAtoms`` option to SelectLoci/HighlightLoci behaviors
-- Make the implicit atoms of bond visuals pickable
-    - Add ``preferAtomPixelPadding`` to Canvas3dInteractionHelper
-- Add points & crosses visuals to Line representation
-- Add ``pickPadding`` config option (look around in case target pixel is empty)
-- Add ``multipleBonds`` param to bond visuals with options: off, symmetric, offset
-- Fix ``argparse`` config in servers.
-
-## [v2.3.3] - 2021-10-01
-
-- Fix direct volume shader
-
-## [v2.3.2] - 2021-10-01
-
-- Prefer WebGL1 on iOS devices until WebGL2 support has stabilized.
-
-## [v2.3.1] - 2021-09-28
-
-- Add Charmm saccharide names
-- Treat missing occupancy column as occupancy of 1
-- Fix line shader not accounting for aspect ratio
-- [Breaking] Fix point repr & shader
-    - Was unusable with ``wboit``
-    - Replaced ``pointFilledCircle`` & ``pointEdgeBleach`` params by ``pointStyle`` (square, circle, fuzzy)
-    - Set ``pointSizeAttenuation`` to false by default
-    - Set ``sizeTheme`` to ``uniform`` by default
-- Add ``markerPriority`` option to Renderer (useful in combination with edges of marking pass)
-- Add support support for ``chem_comp_bond`` and ``struct_conn`` categories (fixes ModelServer behavior where these categories should have been present)
-- Model and VolumeServer: fix argparse config
-
-## [v2.3.0] - 2021-09-06
-
-- Take include/exclude flags into account when displaying aromatic bonds
-- Improve marking performance
-    - Avoid unnecessary draw calls/ui updates when marking
-    - Check if loci is superset of visual
-    - Check if loci overlaps with unit visual
-    - Ensure ``Interval`` is used for ranges instead of ``SortedArray``
-    - Add uniform marker type
-    - Special case for reversing previous mark
-- Add optional marking pass
-    - Outlines visible and hidden parts of highlighted/selected groups
-    - Add highlightStrength/selectStrength renderer params
-
-## [v2.2.3] - 2021-08-25
-
-- Add ``invertCantorPairing`` helper function
-- Add ``Mesh`` processing helper ``.smoothEdges``
-- Smooth border of molecular-surface with ``includeParent`` enabled
-- Hide ``includeParent`` option from gaussian-surface visuals (not particularly useful)
-- Improved ``StructureElement.Loci.size`` performance (for marking large cellpack models)
-- Fix new ``TransformData`` issues (camera/bounding helper not showing up)
-- Improve marking performance (avoid superfluous calls to ``StructureElement.Loci.isWholeStructure``)
-
-## [v2.2.2] - 2021-08-11
-
-- Fix ``TransformData`` issues [#133](https://github.com/molstar/molstar/issues/133)
-- Fix ``mol-script`` query compiler const expression recognition.
-
-## [v2.2.1] - 2021-08-02
-
-- Add surrounding atoms (5 Angstrom) structure selection query
-- [Breaking] Add maxDistance prop to ``IndexPairBonds``
-- Fix coordinateSystem not handled in ``Structure.asParent``
-- Add ``dynamicBonds`` to ``Structure`` props (force re-calc on model change)
-    - Expose as optional param in root structure transform helper
-- Add overpaint support to geometry exporters
-- ``InputObserver`` improvements
-  - normalize wheel speed across browsers/platforms
-  - support Safari gestures (used by ``TrackballControls``)
-  - ``PinchInput.fractionDelta`` and use it in ``TrackballControls``
-
-## [v2.2.0] - 2021-07-31
-
-- Add ``tubularHelices`` parameter to Cartoon representation
-- Add ``SdfFormat`` and update SDF parser to be able to parse data headers according to spec (hopefully :)) #230
-- Fix mononucleotides detected as polymer components (#229)
-- Set default outline scale back to 1
-- Improved DCD reader cell angle handling (interpret near 0 angles as 90 deg)
-- Handle more residue/atom names commonly used in force-fields
-- Add USDZ support to ``geo-export`` extension.
-- Fix ``includeParent`` support for multi-instance bond visuals.
-- Add ``operator`` Loci granularity, selecting everything with the same operator name.
-- Prefer ``_label_seq_id`` fields in secondary structure assignment.
-- Support new EMDB API (https://www.ebi.ac.uk/emdb/api/entry/map/[EMBD-ID]) for EM volume contour levels.
-- ``Canvas3D`` tweaks:
-    - Update ``forceDraw`` logic.
-    - Ensure the scene is re-rendered when viewport size changes.
-    - Support ``noDraw`` mode in ``PluginAnimationLoop``.
-
-## [v2.1.0] - 2021-07-05
-
-- Add parameter for to display aromatic bonds as dashes next to solid cylinder/line.
-- Add backbone representation
-- Fix outline in orthographic mode and set default scale to 2.
-
-## [v2.0.7] - 2021-06-23
-
-- Add ability to specify ``volumeIndex`` in ``Viewer.loadVolumeFromUrl`` to better support Volume Server inputs.
-- Support in-place reordering for trajectory ``Frame.x/y/z`` arrays for better memory efficiency.
-- Fixed text CIF encoder edge cases (most notably single whitespace not being escaped).
-
-## [v2.0.6] - 2021-06-01
-
-- Add glTF (GLB) and STL support to ``geo-export`` extension.
-- Protein crosslink improvements
-    - Change O-S bond distance to allow for NOS bridges (doi:10.1038/s41586-021-03513-3)
-    - Added NOS-bridges query & improved disulfide-bridges query
-- Fix #178: ``IndexPairBonds`` for non-single residue structures (bug due to atom reordering).
-- Add volumetric color smoothing for MolecularSurface and GaussianSurface representations (#173)
-- Fix nested 3d grid lookup that caused results being overwritten in non-covalent interactions computation.
-- Basic implementation of ``BestDatabaseSequenceMapping`` (parse from CIF, color theme, superposition).
-- Add atom id ranges support to Selection UI.
-
-## [v2.0.5] - 2021-04-26
-
-- Ability to pass ``Canvas3DContext`` to ``PluginContext.fromCanvas``.
-- Relative frame support for ``Canvas3D`` viewport.
-- Fix bug in screenshot copy UI.
-- Add ability to select residues from a list of identifiers to the Selection UI.
-- Fix SSAO bugs when used with ``Canvas3D`` viewport.
-- Support for  full pausing (no draw) rendering: ``Canvas3D.pause(true)``.
-- Add ``MeshBuilder.addMesh``.
-- Add ``Torus`` primitive.
-- Lazy volume loading support.
-- [Breaking] ``Viewer.loadVolumeFromUrl`` signature change.
-    - ``loadVolumeFromUrl(url, format, isBinary, isovalues, entryId)`` => ``loadVolumeFromUrl({ url, format, isBinary }, isovalues, { entryId, isLazy })``
-- Add ``TextureMesh`` support to ``geo-export`` extension.
-
-## [v2.0.4] - 2021-04-20
-
-- [WIP] Mesh export extension
-- ``Structure.eachAtomicHierarchyElement`` (#161)
-- Fixed reading multi-line values in SDF format
-- Fixed Measurements UI labels (#166)
-
-## [v2.0.3] - 2021-04-09
-
-- Add support for ``ColorTheme.palette`` designed for providing gradient-like coloring.
-- [Breaking] The ``zip`` function is now asynchronous and expects a ``RuntimeContext``. Also added ``Zip()`` returning a ``Task``.
-- [Breaking] Add ``CubeGridFormat`` in ``alpha-orbitals`` extension.
-
-## [v2.0.2] - 2021-03-29
-
-- Add ``Canvas3D.getRenderObjects``.
-- [WIP] Animate state interpolating, including model trajectories
-- Recognise MSE, SEP, TPO, PTR and PCA as non-standard amino-acids.
-- Fix VolumeFromDensityServerCif transform label
-
-## [v2.0.1] - 2021-03-23
-
-- Exclude tsconfig.commonjs.tsbuildinfo from npm bundle
-
-## [v2.0.0] - 2021-03-23
-
-Too many changes to list as this is the start of the changelog... Notably, default exports are now forbidden.

CITATION.cff

@@ -1,72 +0,0 @@
-cff-version: 1.2.0
-title: >-
-  Mol* library
-message: >-
-  Please cite this software using the metadata from
-  'preferred-citation'.
-authors:
-  - given-names: Alexander S
-    family-names: Rose
-    orcid: 'https://orcid.org/0000-0002-0893-5551'
-  - given-names: David
-    family-names: Sehnal
-    orcid: 'https://orcid.org/0000-0002-0682-3089'
-  - given-names: Sebastian
-    family-names: Bittrich
-    orcid: 'https://orcid.org/0000-0003-3576-0387'
-  - given-names: Áron Samuel
-    family-names: Kovács
-  - given-names: Ludovic
-    family-names: Autin
-    orcid: 'https://orcid.org/0000-0002-2197-191X'
-  - given-names: Michal
-    family-names: Malý
-  - given-names: Jiří
-    family-names: Černý
-  - given-names: Panagiotis
-    family-names: Tourlas
-type: software
-doi: 10.5281/zenodo.3947306
-preferred-citation:
-  authors:
-    - given-names: David
-      family-names: Sehnal
-      orcid: 'https://orcid.org/0000-0002-0682-3089'
-    - given-names: Sebastian
-      family-names: Bittrich
-      orcid: 'https://orcid.org/0000-0003-3576-0387'
-    - given-names: Mandar
-      family-names: Deshpande
-      orcid: 'https://orcid.org/0000-0002-9043-7665'
-    - given-names: Radka
-      family-names: Svobodová
-      orcid: 'https://orcid.org/0000-0002-3840-8760'
-    - given-names: Karel
-      family-names: Berka
-      orcid: 'https://orcid.org/0000-0001-9472-2589'
-    - given-names: Václav
-      family-names: Bazgier
-      orcid: 'https://orcid.org/0000-0003-3393-3010'
-    - given-names: Sameer
-      family-names: Velankar
-      orcid: 'https://orcid.org/0000-0002-8439-5964'
-    - given-names: Stephen K
-      family-names: Burley
-      orcid: 'https://orcid.org/0000-0002-2487-9713'
-    - given-names: Jaroslav
-      family-names: Koča
-      orcid: 'https://orcid.org/0000-0002-2780-4901'
-    - given-names: Alexander S
-      family-names: Rose
-      orcid: 'https://orcid.org/0000-0002-0893-5551'
-  title: >-
-    Mol* Viewer: modern web app for 3D visualization
-    and analysis of large biomolecular structures
-  type: article
-  doi: 10.1093/nar/gkab314
-  journal: "Nucleic Acids Research"
-  issue: W1
-  volume: 49
-  year: 2021
-  month: 7
-  pages: "W431–W437"

README.md

@@ -5,49 +5,40 @@
 
 # Mol*
 
-The goal of **Mol\*** (*/'mol-star/*) is to provide a technology stack that serves as a basis for the next-generation data delivery and analysis tools for (not only) macromolecular structure data. Mol* development was jointly initiated by PDBe and RCSB PDB to combine and build on the strengths of [LiteMol](https://litemol.org) (developed by PDBe) and [NGL](https://nglviewer.org) (developed by RCSB PDB) viewers.
+The goal of **Mol\*** (*/'mol-star/*) is to provide a technology stack that will serve as basis for the next-generation data delivery and analysis tools for macromolecular structure data. This is a collaboration between PDBe and RCSB PDB teams and the development will be open source and available to anyone who wants to use it for developing visualisation tools for macromolecular structure data available from [PDB](https://www.wwpdb.org/) and other institutions.
 
-When using Mol*, please cite:
+This particular project is the implementation of this technology (still under development).
 
-David Sehnal, Sebastian Bittrich, Mandar Deshpande, Radka Svobodová, Karel Berka, Václav Bazgier, Sameer Velankar, Stephen K Burley, Jaroslav Koča, Alexander S Rose: [Mol* Viewer: modern web app for 3D visualization and analysis of large biomolecular structures](https://doi.org/10.1093/nar/gkab314), *Nucleic Acids Research*, 2021; https://doi.org/10.1093/nar/gkab314.
+*If you are looking for the "MOLeculAR structure annoTator", that package is now available on NPM as [MolArt](https://www.npmjs.com/package/molart).*
 
-### Protein Data Bank Integrations
+## Project Overview
 
-- The [pdbe-molstar](https://github.com/molstar/pdbe-molstar) library is the Mol* implementation used by EMBL-EBI data resources such as [PDBe](https://pdbe.org/), [PDBe-KB](https://pdbe-kb.org/) and [AlphaFold DB](https://alphafold.ebi.ac.uk/). This implementation can be used as a JS plugin and a Web component and supports property/attribute-based easy customisation. It provides helper methods to facilitate programmatic interactions between the web application and the 3D viewer. It also provides a superposition view for overlaying all the observed ligand molecules on representative protein conformations.
-
-- [rcsb-molstar](https://github.com/molstar/rcsb-molstar) is the Mol* plugin used by [RCSB PDB](https://www.rcsb.org). The project provides additional presets for the visualization of structure alignments and structure motifs such as ligand binding sites. Furthermore, [rcsb-molstar](https://github.com/molstar/rcsb-molstar) allows to interactively add or hide of (parts of) chains, as seen in the [3D Protein Feature View](https://www.rcsb.org/3d-sequence/4hhb).
-
-
-## Project Structure Overview
-
-The core of Mol* consists of these modules (see under `src/`):
+The core of Mol* currently consists of these modules (see under `src/`):
 
 - `mol-task` Computation abstraction with progress tracking and cancellation support.
-- `mol-data` Collections (integer-based sets, interface to columns/tables, etc.)
+- `mol-data` Collections (integer based sets, interface to columns/tables, etc.)
 - `mol-math` Math related (loosely) algorithms and data structures.
 - `mol-io` Parsing library. Each format is parsed into an interface that corresponds to the data stored by it. Support for common coordinate, experimental/map, and annotation data formats.
 - `mol-model` Data structures and algorithms (such as querying) for representing molecular data (including coordinate, experimental/map, and annotation data).
 - `mol-model-formats` Data format parsers for `mol-model`.
 - `mol-model-props` Common "custom properties".
-- `mol-script` A scripting language for creating representations/scenes and querying (includes the [MolQL query language](https://molql.github.io)).
+- `mol-script` A scriting language for creating representations/scenes and querying (includes the [MolQL query language](https://molql.github.io)).
 - `mol-geo` Creating (molecular) geometries.
 - `mol-theme` Theming for structure, volume and shape representations.
 - `mol-repr` Molecular representations for structures, volumes and shapes.
 - `mol-gl` A wrapper around WebGL.
-- `mol-canvas3d` A low-level 3d view component. Uses `mol-geo` to generate geometries.
+- `mol-canvas3d` A low level 3d view component. Uses `mol-geo` to generate geometries.
 - `mol-state` State representation tree with state saving and automatic updates.
+- `mol-app` Components for builduing UIs.
 - `mol-plugin` Allow to define modular Mol* plugin instances utilizing `mol-state` and `mol-canvas3d`.
-- `mol-plugin-state` State transformations, builders, and managers.
-- `mol-plugin-ui` React-based user interface for the Mol* plugin. Some components of the UI are usable outside the main plugin and can be integrated into 3rd party solutions.
 - `mol-util` Useful things that do not fit elsewhere.
 
-Moreover, the project contains the implementation of `servers`, including
+Moreover, the project contains the imlementation of `servers`, including
 
 - `servers/model` A tool for accessing coordinate and annotation data of molecular structures.
 - `servers/volume` A tool for accessing volumetric experimental data related to molecular structures.
-- `servers/plugin-state` A basic server to store Mol* Plugin states.
 
-The project also contains performance tests (`perf-tests`), `examples`, and `cli` apps (CIF to BinaryCIF converter and JSON domain annotation to CIF converter).
+The project also contains performance tests (`perf-tests`), `examples`, and basic proof of concept `apps` (CIF to BinaryCIF converter and JSON domain annotation to CIF converter).
 
 ## Previous Work
 This project builds on experience from previous solutions:
@@ -68,24 +59,11 @@ This project builds on experience from previous solutions:
 ### Build automatically on file save:
     npm run watch
 
-If working on just the viewer, ``npm run watch-viewer`` will provide shorter compile times.
-
 ### Build with debug mode enabled:
     DEBUG=molstar npm run watch
 
 Debug/production mode in browsers can be turned on/off during runtime by calling ``setMolStarDebugMode(true/false, true/false)`` from the dev console.
 
-### Cleaning and forcing a full rebuild
-    npm run clean
-
-Wipes the `build` and `lib` directories and `.tsbuildinfo` files.
-
-    npm run rebuild
-
-Runs the cleanup script prior to building the project, forcing a full rebuild of the project.
-
-Use these commands to resolve occassional build failures which may arise after some dependency updates. Once done, `npm run build` should work again. Note that full rebuilds take more time to complete.
-
 ### Build for production:
     NODE_ENV=production npm run build
 
@@ -106,32 +84,20 @@ and navigate to `build/viewer`
 
 ### Code generation
 **CIF schemas**
+Install CIFTools `npm install ciftools -g`
 
-    node ./lib/commonjs/cli/cifschema -mip ../../../../mol-data -o src/mol-io/reader/cif/schema/mmcif.ts -p mmCIF
-    node ./lib/commonjs/cli/cifschema -mip ../../../../mol-data -o src/mol-io/reader/cif/schema/ccd.ts -p CCD
-    node ./lib/commonjs/cli/cifschema -mip ../../../../mol-data -o src/mol-io/reader/cif/schema/bird.ts -p BIRD
-    node ./lib/commonjs/cli/cifschema -mip ../../../../mol-data -o src/mol-io/reader/cif/schema/cif-core.ts -p CifCore -aa
-
-**Lipid names**
-
-    node lib/commonjs/cli/lipid-params -o src/mol-model/structure/model/types/lipids.ts
-
-**Ion names**
-
-    node --max-old-space-size=4096 lib/commonjs/cli/chem-comp-dict/create-ions.js src/mol-model/structure/model/types/ions.ts
-
-**Saccharide names**
-
-    node --max-old-space-size=4096 lib/commonjs/cli/chem-comp-dict/create-saccharides.js src/mol-model/structure/model/types/saccharides.ts
+    cifschema -mip ../../../../mol-data -o src/mol-io/reader/cif/schema/mmcif.ts -p mmCIF
+    cifschema -mip ../../../../mol-data -o src/mol-io/reader/cif/schema/ccd.ts -p CCD
+    cifschema -mip ../../../../mol-data -o src/mol-io/reader/cif/schema/bird.ts -p BIRD
 
 **GraphQL schemas**
 
-    node node_modules/@graphql-codegen/cli/cjs/bin -c src/extensions/rcsb/graphql/codegen.yml
+    node data/rcsb-graphql/codegen.js
 
 ### Other scripts
 **Create chem comp bond table**
 
-    node --max-old-space-size=4096 lib/commonjs/cli/chem-comp-dict/create-table.js build/data/ccb.bcif -b
+    export NODE_PATH="lib"; node --max-old-space-size=4096 lib/apps/chem-comp-bond/create-table.js build/data/ccb.bcif -b
 
 **Test model server**
 
@@ -141,33 +107,24 @@ and navigate to `build/viewer`
 
     export NODE_PATH="lib"; node build/state-docs
 
-**Convert any CIF to BinaryCIF (or vice versa)**
+**Convert any CIF to BinaryCIF**
 
-    node lib/commonjs/servers/model/preprocess -i file.cif -ob file.bcif
+    node build/model-server/preprocess -i file.cif -ob file.bcif
 
-To see all available commands, use ``node lib/commonjs/servers/model/preprocess -h``.
-
-Or
-
-    node lib/commonjs/cli/cif2bcif
-
-E.g.
-
-    node lib/commonjs/cli/cif2bcif src.cif out.bcif.gz
-    node lib/commonjs/cli/cif2bcif src.bcif.gz out.cif
+To see all available commands, use ``node build/model-server/preprocess -h``.
 
 ## Development
 
-### Installation
+### Intallation
 
-If node complains about a missing acorn peer dependency, run the following commands
+If node complains about a missine acorn peer dependency, run the following commands
 
     npm update acorn --depth 20
     npm dedupe
 
 ### Editor
 
-To get syntax highlighting for shader and graphql files add the following to Visual Code's settings files and make sure relevant extensions are installed in the editor.
+To get syntax highlighting for shader and graphql files add the following to Visual Code's settings files and make sure relevant extanesions are installed in the editor.
 
     "files.associations": {
         "*.glsl.ts": "glsl",
@@ -179,7 +136,7 @@ To get syntax highlighting for shader and graphql files add the following to Vis
 ## Publish
 
 ### Prerelease
-    npm version prerelease # assumes the current version ends with '-dev.X'
+    npm version prerelease # asumes the current version ends with '-dev.X'
     npm publish --tag next
 
 ### Release
@@ -194,9 +151,11 @@ To get syntax highlighting for shader and graphql files add the following to Vis
 ## Contributing
 Just open an issue or make a pull request. All contributions are welcome.
 
+## Roadmap
+Continually develop this prototype project. As individual modules become stable, make them into standalone libraries.
+
 ## Funding
 Funding sources include but are not limited to:
 * [RCSB PDB](https://www.rcsb.org) funding by a grant [DBI-1338415; PI: SK Burley] from the NSF, the NIH, and the US DoE
 * [PDBe, EMBL-EBI](https://pdbe.org)
-* [CEITEC](https://www.ceitec.eu/)
-* [EntosAI](https://www.entos.ai)
+* [CEITEC](https://www.ceitec.eu/)

data/cif-core.csv

@@ -1,12 +1,6 @@
 audit.block_doi
 
 database_code.depnum_ccdc_archive
-database_code.depnum_ccdc_fiz
-database_code.icsd
-database_code.mdf
-database_code.nbs
-database_code.csd
-database_code.cod
 
 chemical.name_systematic
 chemical.name_common
@@ -24,8 +18,7 @@ atom_type_scat.dispersion_imag
 atom_type_scat.source
 
 space_group.crystal_system
-space_group.name_h-m_full
-space_group.it_number
+space_group.name_H-M_full
 space_group_symop.operation_xyz
 
 cell.length_a
@@ -35,35 +28,33 @@ cell.angle_alpha
 cell.angle_beta
 cell.angle_gamma
 cell.volume
-cell.formula_units_z
+cell.formula_units_Z
 
 atom_site.label
 atom_site.type_symbol
 atom_site.fract_x
 atom_site.fract_y
 atom_site.fract_z
-atom_site.u_iso_or_equiv
+atom_site.U_iso_or_equiv
 atom_site.adp_type
 atom_site.occupancy
 atom_site.calc_flag
 atom_site.refinement_flags
 atom_site.disorder_assembly
 atom_site.disorder_group
+
 atom_site.site_symmetry_multiplicity
 
 atom_site_aniso.label
-atom_site_aniso.u
-atom_site_aniso.u_11
-atom_site_aniso.u_22
-atom_site_aniso.u_33
-atom_site_aniso.u_23
-atom_site_aniso.u_13
-atom_site_aniso.u_12
+atom_site_aniso.U_11
+atom_site_aniso.U_22
+atom_site_aniso.U_33
+atom_site_aniso.U_23
+atom_site_aniso.U_13
+atom_site_aniso.U_12
 
 geom_bond.atom_site_label_1
 geom_bond.atom_site_label_2
 geom_bond.distance
-geom_bond.site_symmetry_1
 geom_bond.site_symmetry_2
-geom_bond.publ_flag
-geom_bond.valence
+geom_bond.publ_flag

data/cif-field-names/bird-field-names.csv

@@ -1,88 +0,0 @@
-pdbx_reference_molecule.prd_id
-pdbx_reference_molecule.name
-pdbx_reference_molecule.represent_as
-pdbx_reference_molecule.type
-pdbx_reference_molecule.type_evidence_code
-pdbx_reference_molecule.class
-pdbx_reference_molecule.class_evidence_code
-pdbx_reference_molecule.formula
-pdbx_reference_molecule.chem_comp_id
-pdbx_reference_molecule.formula_weight
-pdbx_reference_molecule.release_status
-pdbx_reference_molecule.replaces
-pdbx_reference_molecule.replaced_by
-pdbx_reference_molecule.compound_details
-pdbx_reference_molecule.description
-pdbx_reference_molecule.representative_PDB_id_code
-
-pdbx_reference_entity_list.prd_id
-pdbx_reference_entity_list.ref_entity_id
-pdbx_reference_entity_list.component_id
-pdbx_reference_entity_list.type
-pdbx_reference_entity_list.details
-
-pdbx_reference_entity_nonpoly.prd_id
-pdbx_reference_entity_nonpoly.ref_entity_id
-pdbx_reference_entity_nonpoly.name
-pdbx_reference_entity_nonpoly.chem_comp_id
-
-pdbx_reference_entity_link.prd_id
-pdbx_reference_entity_link.link_id
-pdbx_reference_entity_link.link_class
-pdbx_reference_entity_link.ref_entity_id_1
-pdbx_reference_entity_link.entity_seq_num_1
-pdbx_reference_entity_link.comp_id_1
-pdbx_reference_entity_link.atom_id_1
-pdbx_reference_entity_link.ref_entity_id_2
-pdbx_reference_entity_link.entity_seq_num_2
-pdbx_reference_entity_link.comp_id_2
-pdbx_reference_entity_link.atom_id_2
-pdbx_reference_entity_link.value_order
-pdbx_reference_entity_link.component_1
-pdbx_reference_entity_link.component_2
-pdbx_reference_entity_link.details
-
-pdbx_reference_entity_poly_link.prd_id
-pdbx_reference_entity_poly_link.ref_entity_id
-pdbx_reference_entity_poly_link.link_id
-pdbx_reference_entity_poly_link.atom_id_1
-pdbx_reference_entity_poly_link.comp_id_1
-pdbx_reference_entity_poly_link.entity_seq_num_1
-pdbx_reference_entity_poly_link.atom_id_2
-pdbx_reference_entity_poly_link.comp_id_2
-pdbx_reference_entity_poly_link.entity_seq_num_2
-pdbx_reference_entity_poly_link.value_order
-pdbx_reference_entity_poly_link.component_id
-
-pdbx_reference_entity_poly.prd_id
-pdbx_reference_entity_poly.ref_entity_id
-pdbx_reference_entity_poly.db_code
-pdbx_reference_entity_poly.db_name
-pdbx_reference_entity_poly.type
-
-pdbx_reference_entity_sequence.prd_id
-pdbx_reference_entity_sequence.ref_entity_id
-pdbx_reference_entity_sequence.type
-pdbx_reference_entity_sequence.NRP_flag
-pdbx_reference_entity_sequence.one_letter_codes
-
-pdbx_reference_entity_poly_seq.prd_id
-pdbx_reference_entity_poly_seq.ref_entity_id
-pdbx_reference_entity_poly_seq.num
-pdbx_reference_entity_poly_seq.mon_id
-pdbx_reference_entity_poly_seq.parent_mon_id
-pdbx_reference_entity_poly_seq.hetero
-pdbx_reference_entity_poly_seq.observed
-
-pdbx_reference_entity_src_nat.prd_id
-pdbx_reference_entity_src_nat.ref_entity_id
-pdbx_reference_entity_src_nat.ordinal
-pdbx_reference_entity_src_nat.taxid
-pdbx_reference_entity_src_nat.organism_scientific
-pdbx_reference_entity_src_nat.db_code
-pdbx_reference_entity_src_nat.db_name
-
-pdbx_prd_audit.prd_id
-pdbx_prd_audit.date
-pdbx_prd_audit.processing_site
-pdbx_prd_audit.action_type

data/cif-field-names/ccd-field-names.csv

@@ -1,60 +0,0 @@
-chem_comp.id
-chem_comp.name
-chem_comp.type
-chem_comp.pdbx_type
-chem_comp.formula
-chem_comp.mon_nstd_parent_comp_id
-chem_comp.pdbx_synonyms
-chem_comp.pdbx_formal_charge
-chem_comp.pdbx_initial_date
-chem_comp.pdbx_modified_date
-chem_comp.pdbx_ambiguous_flag
-chem_comp.pdbx_release_status
-chem_comp.pdbx_replaced_by
-chem_comp.pdbx_replaces
-chem_comp.formula_weight
-chem_comp.one_letter_code
-chem_comp.three_letter_code
-chem_comp.pdbx_model_coordinates_details
-chem_comp.pdbx_model_coordinates_missing_flag
-chem_comp.pdbx_ideal_coordinates_details
-chem_comp.pdbx_ideal_coordinates_missing_flag
-chem_comp.pdbx_model_coordinates_db_code
-chem_comp.pdbx_processing_site
-
-chem_comp_atom.comp_id
-chem_comp_atom.atom_id
-chem_comp_atom.alt_atom_id
-chem_comp_atom.type_symbol
-chem_comp_atom.charge
-chem_comp_atom.pdbx_align
-chem_comp_atom.pdbx_aromatic_flag
-chem_comp_atom.pdbx_leaving_atom_flag
-chem_comp_atom.pdbx_stereo_config
-chem_comp_atom.model_Cartn_x
-chem_comp_atom.model_Cartn_y
-chem_comp_atom.model_Cartn_z
-chem_comp_atom.pdbx_model_Cartn_x_ideal
-chem_comp_atom.pdbx_model_Cartn_y_ideal
-chem_comp_atom.pdbx_model_Cartn_z_ideal
-chem_comp_atom.pdbx_ordinal
-
-chem_comp_bond.comp_id
-chem_comp_bond.atom_id_1
-chem_comp_bond.atom_id_2
-chem_comp_bond.value_order
-chem_comp_bond.pdbx_aromatic_flag
-chem_comp_bond.pdbx_stereo_config
-chem_comp_bond.pdbx_ordinal
-
-pdbx_chem_comp_descriptor.comp_id
-pdbx_chem_comp_descriptor.type
-pdbx_chem_comp_descriptor.program
-pdbx_chem_comp_descriptor.program_version
-pdbx_chem_comp_descriptor.descriptor
-
-pdbx_chem_comp_identifier.comp_id
-pdbx_chem_comp_identifier.type
-pdbx_chem_comp_identifier.program
-pdbx_chem_comp_identifier.program_version
-pdbx_chem_comp_identifier.identifier

data/cif-field-names/mmcif-field-names.csv

@@ -1,872 +0,0 @@
-atom_sites.entry_id
-atom_sites.fract_transf_matrix
-atom_sites.fract_transf_vector
-
-atom_site.group_PDB
-atom_site.id
-atom_site.type_symbol
-atom_site.label_atom_id
-atom_site.label_alt_id
-atom_site.label_comp_id
-atom_site.label_asym_id
-atom_site.label_entity_id
-atom_site.label_seq_id
-atom_site.pdbx_PDB_ins_code
-atom_site.pdbx_formal_charge
-atom_site.Cartn_x
-atom_site.Cartn_y
-atom_site.Cartn_z
-atom_site.occupancy
-atom_site.B_iso_or_equiv
-atom_site.auth_atom_id
-atom_site.auth_comp_id
-atom_site.auth_asym_id
-atom_site.auth_seq_id
-atom_site.pdbx_PDB_model_num
-atom_site.ihm_model_id
-atom_site.pdbx_label_index
-atom_site.pdbx_sifts_xref_db_name
-atom_site.pdbx_sifts_xref_db_acc
-atom_site.pdbx_sifts_xref_db_num
-atom_site.pdbx_sifts_xref_db_res
-
-atom_site_anisotrop.id
-atom_site_anisotrop.U
-atom_site_anisotrop.U_esd
-atom_site_anisotrop.pdbx_PDB_ins_code
-atom_site_anisotrop.pdbx_auth_asym_id
-atom_site_anisotrop.pdbx_auth_atom_id
-atom_site_anisotrop.pdbx_auth_comp_id
-atom_site_anisotrop.pdbx_auth_seq_id
-atom_site_anisotrop.pdbx_label_alt_id
-atom_site_anisotrop.pdbx_label_asym_id
-atom_site_anisotrop.pdbx_label_atom_id
-atom_site_anisotrop.pdbx_label_comp_id
-atom_site_anisotrop.pdbx_label_seq_id
-atom_site_anisotrop.type_symbol
-
-chem_comp.id
-chem_comp.type
-chem_comp.mon_nstd_flag
-chem_comp.name
-chem_comp.pdbx_synonyms
-chem_comp.formula
-chem_comp.formula_weight
-
-chem_comp_bond.comp_id
-chem_comp_bond.pdbx_stereo_config
-chem_comp_bond.pdbx_ordinal
-chem_comp_bond.pdbx_aromatic_flag
-chem_comp_bond.atom_id_1
-chem_comp_bond.atom_id_2
-chem_comp_bond.value_order
-
-pdbx_chem_comp_identifier.comp_id
-pdbx_chem_comp_identifier.type
-pdbx_chem_comp_identifier.program
-pdbx_chem_comp_identifier.program_version
-pdbx_chem_comp_identifier.identifier
-
-pdbx_chem_comp_related.comp_id
-pdbx_chem_comp_related.related_comp_id
-pdbx_chem_comp_related.relationship_type
-pdbx_chem_comp_related.details
-
-pdbx_chem_comp_synonyms.comp_id
-pdbx_chem_comp_synonyms.name
-pdbx_chem_comp_synonyms.provenance
-
-cell.entry_id
-cell.length_a
-cell.length_b
-cell.length_c
-cell.angle_alpha
-cell.angle_beta
-cell.angle_gamma
-cell.Z_PDB
-cell.pdbx_unique_axis
-
-pdbx_database_related.db_name
-pdbx_database_related.details
-pdbx_database_related.db_id
-pdbx_database_related.content_type
-
-pdbx_database_status.status_code
-pdbx_database_status.status_code_sf
-pdbx_database_status.status_code_mr
-pdbx_database_status.entry_id
-pdbx_database_status.recvd_initial_deposition_date
-pdbx_database_status.SG_entry
-pdbx_database_status.deposit_site
-pdbx_database_status.process_site
-pdbx_database_status.status_code_cs
-pdbx_database_status.methods_development_category
-pdbx_database_status.pdb_format_compatible
-
-entity.id
-entity.type
-entity.src_method
-entity.pdbx_description
-entity.formula_weight
-entity.pdbx_number_of_molecules
-entity.details
-entity.pdbx_mutation
-entity.pdbx_fragment
-entity.pdbx_ec
-
-entity_poly.entity_id
-entity_poly.type
-entity_poly.nstd_linkage
-entity_poly.nstd_monomer
-entity_poly.pdbx_seq_one_letter_code
-entity_poly.pdbx_seq_one_letter_code_can
-entity_poly.pdbx_strand_id
-entity_poly.pdbx_target_identifier
-
-entity_poly_seq.entity_id
-entity_poly_seq.num
-entity_poly_seq.mon_id
-entity_poly_seq.hetero
-
-entity_src_gen.entity_id
-entity_src_gen.pdbx_src_id
-entity_src_gen.pdbx_beg_seq_num
-entity_src_gen.pdbx_end_seq_num
-entity_src_gen.pdbx_gene_src_gene
-entity_src_gen.pdbx_gene_src_scientific_name
-entity_src_gen.plasmid_name
-
-entity_src_nat.entity_id
-entity_src_nat.pdbx_src_id
-entity_src_nat.pdbx_beg_seq_num
-entity_src_nat.pdbx_end_seq_num
-entity_src_nat.pdbx_organism_scientific
-entity_src_nat.pdbx_plasmid_name
-
-pdbx_entity_instance_feature.ordinal
-pdbx_entity_instance_feature.feature_type
-pdbx_entity_instance_feature.details
-pdbx_entity_instance_feature.asym_id
-pdbx_entity_instance_feature.comp_id
-pdbx_entity_instance_feature.seq_num
-pdbx_entity_instance_feature.auth_asym_id
-pdbx_entity_instance_feature.auth_comp_id
-pdbx_entity_instance_feature.auth_seq_num
-
-pdbx_entity_src_syn.entity_id
-pdbx_entity_src_syn.pdbx_src_id
-pdbx_entity_src_syn.pdbx_beg_seq_num
-pdbx_entity_src_syn.pdbx_end_seq_num
-pdbx_entity_src_syn.organism_scientific
-
-pdbx_entity_branch.entity_id
-pdbx_entity_branch.type
-
-pdbx_entity_branch_list.entity_id
-pdbx_entity_branch_list.comp_id
-pdbx_entity_branch_list.num
-pdbx_entity_branch_list.hetero
-
-pdbx_entity_branch_link.link_id
-pdbx_entity_branch_link.entity_id
-pdbx_entity_branch_link.entity_branch_list_num_1
-pdbx_entity_branch_link.comp_id_1
-pdbx_entity_branch_link.atom_id_1
-pdbx_entity_branch_link.leaving_atom_id_1
-pdbx_entity_branch_link.atom_stereo_config_1
-pdbx_entity_branch_link.entity_branch_list_num_2
-pdbx_entity_branch_link.comp_id_2
-pdbx_entity_branch_link.atom_id_2
-pdbx_entity_branch_link.leaving_atom_id_2
-pdbx_entity_branch_link.atom_stereo_config_2
-pdbx_entity_branch_link.value_order
-pdbx_entity_branch_link.details
-
-pdbx_branch_scheme.asym_id
-pdbx_branch_scheme.entity_id
-pdbx_branch_scheme.mon_id
-pdbx_branch_scheme.num
-pdbx_branch_scheme.auth_asym_id
-pdbx_branch_scheme.auth_mon_id
-pdbx_branch_scheme.auth_seq_num
-pdbx_branch_scheme.hetero
-pdbx_branch_scheme.pdb_mon_id
-pdbx_branch_scheme.pdb_asym_id
-pdbx_branch_scheme.pdb_seq_num
-
-pdbx_entity_branch_descriptor.ordinal
-pdbx_entity_branch_descriptor.entity_id
-pdbx_entity_branch_descriptor.descriptor
-pdbx_entity_branch_descriptor.type
-pdbx_entity_branch_descriptor.program
-pdbx_entity_branch_descriptor.program_version
-
-pdbx_entity_nonpoly.entity_id
-pdbx_entity_nonpoly.name
-pdbx_entity_nonpoly.comp_id
-
-pdbx_nonpoly_scheme.asym_id
-pdbx_nonpoly_scheme.entity_id
-pdbx_nonpoly_scheme.mon_id
-pdbx_nonpoly_scheme.ndb_seq_num
-pdbx_nonpoly_scheme.pdb_seq_num
-pdbx_nonpoly_scheme.auth_seq_num
-pdbx_nonpoly_scheme.pdb_mon_id
-pdbx_nonpoly_scheme.auth_mon_id
-pdbx_nonpoly_scheme.pdb_strand_id
-pdbx_nonpoly_scheme.pdb_ins_code
-
-entry.id
-
-audit_conform.dict_name
-audit_conform.dict_version
-audit_conform.dict_location
-
-database_2.database_id
-database_2.database_code
-
-audit_author.name
-audit_author.pdbx_ordinal
-audit_author.identifier_ORCID
-
-citation.id
-citation.title
-citation.journal_abbrev
-citation.journal_volume
-citation.page_first
-citation.page_last
-citation.year
-citation.journal_id_ASTM
-citation.country
-citation.journal_id_ISSN
-citation.journal_id_CSD
-citation.book_publisher
-citation.pdbx_database_id_PubMed
-citation.pdbx_database_id_DOI
-
-citation_author.citation_id
-citation_author.name
-citation_author.ordinal
-
-exptl.entry_id
-exptl.method
-
-software.classification
-software.date
-software.description
-software.name
-software.pdbx_ordinal
-software.type
-software.version
-
-struct.entry_id
-struct.title
-struct.pdbx_descriptor
-
-struct_asym.id
-struct_asym.pdbx_blank_PDB_chainid_flag
-struct_asym.pdbx_modified
-struct_asym.entity_id
-struct_asym.details
-
-struct_conf.conf_type_id
-struct_conf.id
-struct_conf.pdbx_PDB_helix_id
-struct_conf.beg_label_comp_id
-struct_conf.beg_label_asym_id
-struct_conf.beg_label_seq_id
-struct_conf.pdbx_beg_PDB_ins_code
-struct_conf.end_label_comp_id
-struct_conf.end_label_asym_id
-struct_conf.end_label_seq_id
-struct_conf.pdbx_end_PDB_ins_code
-struct_conf.beg_auth_comp_id
-struct_conf.beg_auth_asym_id
-struct_conf.beg_auth_seq_id
-struct_conf.end_auth_comp_id
-struct_conf.end_auth_asym_id
-struct_conf.end_auth_seq_id
-struct_conf.pdbx_PDB_helix_class
-struct_conf.details
-struct_conf.pdbx_PDB_helix_length
-
-struct_conn.id
-struct_conn.conn_type_id
-struct_conn.pdbx_PDB_id
-struct_conn.ptnr1_label_asym_id
-struct_conn.ptnr1_label_comp_id
-struct_conn.ptnr1_label_seq_id
-struct_conn.ptnr1_label_atom_id
-struct_conn.pdbx_ptnr1_label_alt_id
-struct_conn.pdbx_ptnr1_PDB_ins_code
-struct_conn.pdbx_ptnr1_standard_comp_id
-struct_conn.ptnr1_symmetry
-struct_conn.ptnr2_label_asym_id
-struct_conn.ptnr2_label_comp_id
-struct_conn.ptnr2_label_seq_id
-struct_conn.ptnr2_label_atom_id
-struct_conn.pdbx_ptnr2_label_alt_id
-struct_conn.pdbx_ptnr2_PDB_ins_code
-struct_conn.ptnr1_auth_asym_id
-struct_conn.ptnr1_auth_comp_id
-struct_conn.ptnr1_auth_seq_id
-struct_conn.ptnr2_auth_asym_id
-struct_conn.ptnr2_auth_comp_id
-struct_conn.ptnr2_auth_seq_id
-struct_conn.ptnr2_symmetry
-struct_conn.pdbx_ptnr3_label_atom_id
-struct_conn.pdbx_ptnr3_label_seq_id
-struct_conn.pdbx_ptnr3_label_comp_id
-struct_conn.pdbx_ptnr3_label_asym_id
-struct_conn.pdbx_ptnr3_label_alt_id
-struct_conn.pdbx_ptnr3_PDB_ins_code
-struct_conn.details
-struct_conn.pdbx_dist_value
-struct_conn.pdbx_value_order
-
-struct_conn_type.id
-struct_conn_type.criteria
-struct_conn_type.reference
-
-struct_keywords.entry_id
-struct_keywords.pdbx_keywords
-struct_keywords.text
-
-struct_ncs_oper.id
-struct_ncs_oper.code
-struct_ncs_oper.matrix
-struct_ncs_oper.vector
-struct_ncs_oper.details
-
-struct_sheet_range.sheet_id
-struct_sheet_range.id
-struct_sheet_range.beg_label_comp_id
-struct_sheet_range.beg_label_asym_id
-struct_sheet_range.beg_label_seq_id
-struct_sheet_range.pdbx_beg_PDB_ins_code
-struct_sheet_range.end_label_comp_id
-struct_sheet_range.end_label_asym_id
-struct_sheet_range.end_label_seq_id
-struct_sheet_range.pdbx_end_PDB_ins_code
-struct_sheet_range.beg_auth_comp_id
-struct_sheet_range.beg_auth_asym_id
-struct_sheet_range.beg_auth_seq_id
-struct_sheet_range.end_auth_comp_id
-struct_sheet_range.end_auth_asym_id
-struct_sheet_range.end_auth_seq_id
-
-struct_site.id
-struct_site.pdbx_evidence_code
-struct_site.pdbx_auth_asym_id
-struct_site.pdbx_auth_comp_id
-struct_site.pdbx_auth_seq_id
-struct_site.pdbx_auth_ins_code
-struct_site.pdbx_num_residues
-struct_site.details
-
-struct_site_gen.id
-struct_site_gen.site_id
-struct_site_gen.pdbx_num_res
-struct_site_gen.label_comp_id
-struct_site_gen.label_asym_id
-struct_site_gen.label_seq_id
-struct_site_gen.pdbx_auth_ins_code
-struct_site_gen.auth_comp_id
-struct_site_gen.auth_asym_id
-struct_site_gen.auth_seq_id
-struct_site_gen.label_atom_id
-struct_site_gen.label_alt_id
-struct_site_gen.symmetry
-struct_site_gen.details
-
-symmetry.entry_id
-symmetry.cell_setting
-symmetry.Int_Tables_number
-symmetry.space_group_name_Hall
-symmetry.space_group_name_H-M
-
-pdbx_molecule.instance_id
-pdbx_molecule.prd_id
-pdbx_molecule.asym_id
-
-pdbx_molecule_features.prd_id
-pdbx_molecule_features.name
-pdbx_molecule_features.type
-pdbx_molecule_features.class
-pdbx_molecule_features.details
-
-pdbx_reference_entity_link.prd_id
-pdbx_reference_entity_link.link_id
-pdbx_reference_entity_link.link_class
-pdbx_reference_entity_link.ref_entity_id_1
-pdbx_reference_entity_link.entity_seq_num_1
-pdbx_reference_entity_link.comp_id_1
-pdbx_reference_entity_link.atom_id_1
-pdbx_reference_entity_link.ref_entity_id_2
-pdbx_reference_entity_link.entity_seq_num_2
-pdbx_reference_entity_link.comp_id_2
-pdbx_reference_entity_link.atom_id_2
-pdbx_reference_entity_link.value_order
-pdbx_reference_entity_link.component_1
-pdbx_reference_entity_link.component_2
-pdbx_reference_entity_link.details
-
-pdbx_reference_entity_list.prd_id
-pdbx_reference_entity_list.ref_entity_id
-pdbx_reference_entity_list.component_id
-pdbx_reference_entity_list.type
-pdbx_reference_entity_list.details
-
-pdbx_reference_entity_poly_link.prd_id
-pdbx_reference_entity_poly_link.ref_entity_id
-pdbx_reference_entity_poly_link.link_id
-pdbx_reference_entity_poly_link.atom_id_1
-pdbx_reference_entity_poly_link.comp_id_1
-pdbx_reference_entity_poly_link.entity_seq_num_1
-pdbx_reference_entity_poly_link.atom_id_2
-pdbx_reference_entity_poly_link.comp_id_2
-pdbx_reference_entity_poly_link.entity_seq_num_2
-pdbx_reference_entity_poly_link.value_order
-pdbx_reference_entity_poly_link.component_id
-
-pdbx_struct_assembly.id
-pdbx_struct_assembly.details
-pdbx_struct_assembly.method_details
-pdbx_struct_assembly.oligomeric_details
-pdbx_struct_assembly.oligomeric_count
-
-pdbx_struct_assembly_gen.assembly_id
-pdbx_struct_assembly_gen.oper_expression
-pdbx_struct_assembly_gen.asym_id_list
-
-pdbx_struct_oper_list.id
-pdbx_struct_oper_list.type
-pdbx_struct_oper_list.name
-pdbx_struct_oper_list.symmetry_operation
-pdbx_struct_oper_list.matrix
-pdbx_struct_oper_list.vector
-
-pdbx_struct_mod_residue.id
-pdbx_struct_mod_residue.label_asym_id
-pdbx_struct_mod_residue.label_seq_id
-pdbx_struct_mod_residue.label_comp_id
-pdbx_struct_mod_residue.auth_asym_id
-pdbx_struct_mod_residue.auth_seq_id
-pdbx_struct_mod_residue.auth_comp_id
-pdbx_struct_mod_residue.PDB_ins_code
-pdbx_struct_mod_residue.parent_comp_id
-pdbx_struct_mod_residue.details
-
-pdbx_unobs_or_zero_occ_residues.id
-pdbx_unobs_or_zero_occ_residues.PDB_model_num
-pdbx_unobs_or_zero_occ_residues.polymer_flag
-pdbx_unobs_or_zero_occ_residues.occupancy_flag
-pdbx_unobs_or_zero_occ_residues.auth_asym_id
-pdbx_unobs_or_zero_occ_residues.auth_comp_id
-pdbx_unobs_or_zero_occ_residues.auth_seq_id
-pdbx_unobs_or_zero_occ_residues.PDB_ins_code
-pdbx_unobs_or_zero_occ_residues.label_asym_id
-pdbx_unobs_or_zero_occ_residues.label_comp_id
-pdbx_unobs_or_zero_occ_residues.label_seq_id
-
-ihm_struct_assembly.id
-ihm_struct_assembly.name
-ihm_struct_assembly.description
-
-ihm_struct_assembly_details.id
-ihm_struct_assembly_details.assembly_id
-ihm_struct_assembly_details.parent_assembly_id
-ihm_struct_assembly_details.entity_description
-ihm_struct_assembly_details.entity_id
-ihm_struct_assembly_details.asym_id
-ihm_struct_assembly_details.entity_poly_segment_id
-
-ihm_model_representation.id
-ihm_model_representation.name
-ihm_model_representation.details
-
-ihm_model_representation_details.id
-ihm_model_representation_details.representation_id
-ihm_model_representation_details.entity_id
-ihm_model_representation_details.entity_description
-ihm_model_representation_details.entity_asym_id
-ihm_model_representation_details.entity_poly_segment_id
-ihm_model_representation_details.model_object_primitive
-ihm_model_representation_details.starting_model_id
-ihm_model_representation_details.model_mode
-ihm_model_representation_details.model_granularity
-ihm_model_representation_details.model_object_count
-
-ihm_external_reference_info.reference_id
-ihm_external_reference_info.reference_provider
-ihm_external_reference_info.reference_type
-ihm_external_reference_info.reference
-ihm_external_reference_info.refers_to
-ihm_external_reference_info.associated_url
-
-ihm_external_files.id
-ihm_external_files.reference_id
-ihm_external_files.file_path
-ihm_external_files.content_type
-ihm_external_files.file_size_bytes
-ihm_external_files.details
-
-ihm_dataset_list.id
-ihm_dataset_list.data_type
-ihm_dataset_list.database_hosted
-
-ihm_dataset_group.id
-ihm_dataset_group.name
-ihm_dataset_group.application
-ihm_dataset_group.details
-
-ihm_dataset_group_link.group_id
-ihm_dataset_group_link.dataset_list_id
-
-ihm_dataset_external_reference.id
-ihm_dataset_external_reference.dataset_list_id
-ihm_dataset_external_reference.file_id
-
-ihm_dataset_related_db_reference.id
-ihm_dataset_related_db_reference.dataset_list_id
-ihm_dataset_related_db_reference.db_name
-ihm_dataset_related_db_reference.accession_code
-ihm_dataset_related_db_reference.version
-ihm_dataset_related_db_reference.details
-
-ihm_related_datasets.dataset_list_id_derived
-ihm_related_datasets.dataset_list_id_primary
-
-ihm_poly_residue_feature.ordinal_id
-ihm_poly_residue_feature.feature_id
-ihm_poly_residue_feature.entity_id
-ihm_poly_residue_feature.asym_id
-ihm_poly_residue_feature.seq_id_begin
-ihm_poly_residue_feature.comp_id_begin
-ihm_poly_residue_feature.seq_id_end
-ihm_poly_residue_feature.comp_id_end
-
-ihm_feature_list.feature_id
-ihm_feature_list.feature_type
-ihm_feature_list.entity_type
-
-ihm_cross_link_list.id
-ihm_cross_link_list.group_id
-ihm_cross_link_list.entity_description_1
-ihm_cross_link_list.entity_id_1
-ihm_cross_link_list.seq_id_1
-ihm_cross_link_list.comp_id_1
-ihm_cross_link_list.entity_description_2
-ihm_cross_link_list.entity_id_2
-ihm_cross_link_list.seq_id_2
-ihm_cross_link_list.comp_id_2
-ihm_cross_link_list.linker_type
-ihm_cross_link_list.dataset_list_id
-
-ihm_cross_link_restraint.id
-ihm_cross_link_restraint.group_id
-ihm_cross_link_restraint.entity_id_1
-ihm_cross_link_restraint.asym_id_1
-ihm_cross_link_restraint.seq_id_1
-ihm_cross_link_restraint.atom_id_1
-ihm_cross_link_restraint.comp_id_1
-ihm_cross_link_restraint.entity_id_2
-ihm_cross_link_restraint.asym_id_2
-ihm_cross_link_restraint.seq_id_2
-ihm_cross_link_restraint.atom_id_2
-ihm_cross_link_restraint.comp_id_2
-ihm_cross_link_restraint.restraint_type
-ihm_cross_link_restraint.conditional_crosslink_flag
-ihm_cross_link_restraint.model_granularity
-ihm_cross_link_restraint.distance_threshold
-ihm_cross_link_restraint.psi
-ihm_cross_link_restraint.sigma_1
-ihm_cross_link_restraint.sigma_2
-
-ihm_cross_link_result_parameters.id
-ihm_cross_link_result_parameters.restraint_id
-ihm_cross_link_result_parameters.model_id
-ihm_cross_link_result_parameters.psi
-ihm_cross_link_result_parameters.sigma_1
-ihm_cross_link_result_parameters.sigma_2
-
-ihm_sas_restraint.id
-ihm_sas_restraint.dataset_list_id
-ihm_sas_restraint.model_id
-ihm_sas_restraint.struct_assembly_id
-ihm_sas_restraint.profile_segment_flag
-ihm_sas_restraint.fitting_atom_type
-ihm_sas_restraint.fitting_method
-ihm_sas_restraint.fitting_state
-ihm_sas_restraint.radius_of_gyration
-ihm_sas_restraint.chi_value
-ihm_sas_restraint.details
-
-ihm_derived_distance_restraint.id
-ihm_derived_distance_restraint.group_id
-ihm_derived_distance_restraint.feature_id_1
-ihm_derived_distance_restraint.feature_id_2
-ihm_derived_distance_restraint.group_conditionality
-ihm_derived_distance_restraint.restraint_type
-ihm_derived_distance_restraint.distance_upper_limit
-ihm_derived_distance_restraint.random_exclusion_fraction
-ihm_derived_distance_restraint.dataset_list_id
-
-ihm_2dem_class_average_restraint.id
-ihm_2dem_class_average_restraint.dataset_list_id
-ihm_2dem_class_average_restraint.number_raw_micrographs
-ihm_2dem_class_average_restraint.pixel_size_width
-ihm_2dem_class_average_restraint.pixel_size_height
-ihm_2dem_class_average_restraint.image_resolution
-ihm_2dem_class_average_restraint.image_segment_flag
-ihm_2dem_class_average_restraint.number_of_projections
-ihm_2dem_class_average_restraint.struct_assembly_id
-ihm_2dem_class_average_restraint.details
-
-ihm_2dem_class_average_fitting.id
-ihm_2dem_class_average_fitting.restraint_id
-ihm_2dem_class_average_fitting.model_id
-ihm_2dem_class_average_fitting.cross_correlation_coefficient
-ihm_2dem_class_average_fitting.rot_matrix
-ihm_2dem_class_average_fitting.tr_vector
-
-ihm_3dem_restraint.id
-ihm_3dem_restraint.dataset_list_id
-ihm_3dem_restraint.fitting_method
-ihm_3dem_restraint.struct_assembly_id
-ihm_3dem_restraint.number_of_gaussians
-ihm_3dem_restraint.model_id
-ihm_3dem_restraint.cross_correlation_coefficient
-
-ihm_predicted_contact_restraint.id
-ihm_predicted_contact_restraint.group_id
-ihm_predicted_contact_restraint.entity_id_1
-ihm_predicted_contact_restraint.asym_id_1
-ihm_predicted_contact_restraint.seq_id_1
-ihm_predicted_contact_restraint.comp_id_1
-ihm_predicted_contact_restraint.rep_atom_1
-ihm_predicted_contact_restraint.entity_id_2
-ihm_predicted_contact_restraint.asym_id_2
-ihm_predicted_contact_restraint.seq_id_2
-ihm_predicted_contact_restraint.comp_id_2
-ihm_predicted_contact_restraint.rep_atom_2
-ihm_predicted_contact_restraint.restraint_type
-ihm_predicted_contact_restraint.distance_lower_limit
-ihm_predicted_contact_restraint.distance_upper_limit
-ihm_predicted_contact_restraint.probability
-ihm_predicted_contact_restraint.model_granularity
-ihm_predicted_contact_restraint.dataset_list_id
-ihm_predicted_contact_restraint.software_id
-
-ihm_starting_model_details.starting_model_id
-ihm_starting_model_details.entity_id
-ihm_starting_model_details.entity_description
-ihm_starting_model_details.asym_id
-ihm_starting_model_details.entity_poly_segment_id
-ihm_starting_model_details.starting_model_source
-ihm_starting_model_details.starting_model_auth_asym_id
-ihm_starting_model_details.starting_model_sequence_offset
-ihm_starting_model_details.dataset_list_id
-
-ihm_starting_comparative_models.id
-ihm_starting_comparative_models.starting_model_id
-ihm_starting_comparative_models.starting_model_auth_asym_id
-ihm_starting_comparative_models.starting_model_seq_id_begin
-ihm_starting_comparative_models.starting_model_seq_id_end
-ihm_starting_comparative_models.template_auth_asym_id
-ihm_starting_comparative_models.template_seq_id_begin
-ihm_starting_comparative_models.template_seq_id_end
-ihm_starting_comparative_models.template_sequence_identity
-ihm_starting_comparative_models.template_sequence_identity_denominator
-ihm_starting_comparative_models.template_dataset_list_id
-ihm_starting_comparative_models.alignment_file_id
-
-ihm_starting_model_coord.starting_model_id
-ihm_starting_model_coord.group_PDB
-ihm_starting_model_coord.id
-ihm_starting_model_coord.type_symbol
-ihm_starting_model_coord.atom_id
-ihm_starting_model_coord.comp_id
-ihm_starting_model_coord.entity_id
-ihm_starting_model_coord.asym_id
-ihm_starting_model_coord.seq_id
-ihm_starting_model_coord.Cartn_x
-ihm_starting_model_coord.Cartn_y
-ihm_starting_model_coord.Cartn_z
-ihm_starting_model_coord.B_iso_or_equiv
-ihm_starting_model_coord.ordinal_id
-
-ihm_starting_model_seq_dif.id
-ihm_starting_model_seq_dif.entity_id
-ihm_starting_model_seq_dif.asym_id
-ihm_starting_model_seq_dif.seq_id
-ihm_starting_model_seq_dif.comp_id
-ihm_starting_model_seq_dif.starting_model_id
-ihm_starting_model_seq_dif.db_asym_id
-ihm_starting_model_seq_dif.db_seq_id
-ihm_starting_model_seq_dif.db_comp_id
-ihm_starting_model_seq_dif.details
-
-ihm_modeling_protocol.id
-ihm_modeling_protocol.protocol_name
-ihm_modeling_protocol.num_steps
-
-ihm_modeling_protocol_details.id
-ihm_modeling_protocol_details.protocol_id
-ihm_modeling_protocol_details.step_id
-ihm_modeling_protocol_details.struct_assembly_id
-ihm_modeling_protocol_details.dataset_group_id
-ihm_modeling_protocol_details.struct_assembly_description
-ihm_modeling_protocol_details.step_name
-ihm_modeling_protocol_details.step_method
-ihm_modeling_protocol_details.num_models_begin
-ihm_modeling_protocol_details.num_models_end
-ihm_modeling_protocol_details.multi_scale_flag
-ihm_modeling_protocol_details.multi_state_flag
-ihm_modeling_protocol_details.ordered_flag
-ihm_modeling_protocol_details.software_id
-ihm_modeling_protocol_details.script_file_id
-
-ihm_modeling_post_process.id
-ihm_modeling_post_process.protocol_id
-ihm_modeling_post_process.analysis_id
-ihm_modeling_post_process.step_id
-ihm_modeling_post_process.type
-ihm_modeling_post_process.feature
-ihm_modeling_post_process.num_models_begin
-ihm_modeling_post_process.num_models_end
-
-ihm_ensemble_info.ensemble_id
-ihm_ensemble_info.ensemble_name
-ihm_ensemble_info.post_process_id
-ihm_ensemble_info.model_group_id
-ihm_ensemble_info.ensemble_clustering_method
-ihm_ensemble_info.ensemble_clustering_feature
-ihm_ensemble_info.num_ensemble_models
-ihm_ensemble_info.num_ensemble_models_deposited
-ihm_ensemble_info.ensemble_precision_value
-ihm_ensemble_info.ensemble_file_id
-
-ihm_localization_density_files.id
-ihm_localization_density_files.file_id
-ihm_localization_density_files.ensemble_id
-ihm_localization_density_files.entity_id
-ihm_localization_density_files.asym_id
-ihm_localization_density_files.entity_poly_segment_id
-
-ihm_model_list.model_id
-ihm_model_list.model_name
-ihm_model_list.assembly_id
-ihm_model_list.protocol_id
-ihm_model_list.representation_id
-
-ihm_model_group.id
-ihm_model_group.name
-ihm_model_group.details
-
-ihm_model_group_link.group_id
-ihm_model_group_link.model_id
-
-ihm_model_representative.id
-ihm_model_representative.model_group_id
-ihm_model_representative.model_id
-ihm_model_representative.selection_criteria
-
-ihm_sphere_obj_site.id
-ihm_sphere_obj_site.entity_id
-ihm_sphere_obj_site.seq_id_begin
-ihm_sphere_obj_site.seq_id_end
-ihm_sphere_obj_site.asym_id
-ihm_sphere_obj_site.Cartn_x
-ihm_sphere_obj_site.Cartn_y
-ihm_sphere_obj_site.Cartn_z
-ihm_sphere_obj_site.object_radius
-ihm_sphere_obj_site.rmsf
-ihm_sphere_obj_site.model_id
-
-ihm_gaussian_obj_site.id
-ihm_gaussian_obj_site.entity_id
-ihm_gaussian_obj_site.seq_id_begin
-ihm_gaussian_obj_site.seq_id_end
-ihm_gaussian_obj_site.asym_id
-ihm_gaussian_obj_site.mean_Cartn_x
-ihm_gaussian_obj_site.mean_Cartn_y
-ihm_gaussian_obj_site.mean_Cartn_z
-ihm_gaussian_obj_site.weight
-ihm_gaussian_obj_site.covariance_matrix
-ihm_gaussian_obj_site.model_id
-
-ihm_gaussian_obj_ensemble.id
-ihm_gaussian_obj_ensemble.entity_id
-ihm_gaussian_obj_ensemble.seq_id_begin
-ihm_gaussian_obj_ensemble.seq_id_end
-ihm_gaussian_obj_ensemble.asym_id
-ihm_gaussian_obj_ensemble.mean_Cartn_x
-ihm_gaussian_obj_ensemble.mean_Cartn_y
-ihm_gaussian_obj_ensemble.mean_Cartn_z
-ihm_gaussian_obj_ensemble.weight
-ihm_gaussian_obj_ensemble.covariance_matrix
-ihm_gaussian_obj_ensemble.ensemble_id
-
-ihm_multi_state_modeling.state_id
-ihm_multi_state_modeling.state_group_id
-ihm_multi_state_modeling.population_fraction
-ihm_multi_state_modeling.population_fraction_sd
-ihm_multi_state_modeling.state_type
-ihm_multi_state_modeling.state_name
-ihm_multi_state_modeling.experiment_type
-ihm_multi_state_modeling.details
-
-ma_data.content_type
-ma_data.content_type_other_details
-ma_data.id
-ma_data.name
-
-ma_model_list.data_id
-ma_model_list.model_group_id
-ma_model_list.model_group_name
-ma_model_list.model_id
-ma_model_list.model_name
-ma_model_list.model_type
-ma_model_list.ordinal_id
-
-ma_qa_metric.id
-ma_qa_metric.mode
-ma_qa_metric.name
-ma_qa_metric.software_group_id
-ma_qa_metric.type
-
-ma_qa_metric_global.metric_id
-ma_qa_metric_global.metric_value
-ma_qa_metric_global.model_id
-ma_qa_metric_global.ordinal_id
-
-ma_qa_metric_local.label_asym_id
-ma_qa_metric_local.label_comp_id
-ma_qa_metric_local.label_seq_id
-ma_qa_metric_local.metric_id
-ma_qa_metric_local.metric_value
-ma_qa_metric_local.model_id
-ma_qa_metric_local.ordinal_id
-
-ma_software_group.group_id
-ma_software_group.ordinal_id
-ma_software_group.software_id
-
-ma_target_entity.data_id
-ma_target_entity.entity_id
-ma_target_entity.origin
-
-ma_target_entity_instance.asym_id
-ma_target_entity_instance.details
-ma_target_entity_instance.entity_id
-
-ma_target_ref_db_details.db_accession
-ma_target_ref_db_details.db_code
-ma_target_ref_db_details.db_name
-ma_target_ref_db_details.ncbi_taxonomy_id
-ma_target_ref_db_details.organism_scientific
-ma_target_ref_db_details.seq_db_align_begin
-ma_target_ref_db_details.seq_db_align_end
-ma_target_ref_db_details.seq_db_isoform
-ma_target_ref_db_details.target_entity_id

data/cif-field-names/mmtf-filter.csv

@@ -1,76 +0,0 @@
-cell.length_a
-cell.length_b
-cell.length_c
-cell.angle_alpha
-cell.angle_beta
-cell.angle_gamma
-
-symmetry.space_group_name_H-M
-
-entry.id
-
-struct.title
-
-pdbx_database_status.recvd_initial_deposition_date
-
-pdbx_audit_revision_history.revision_date
-
-struct_ncs_oper
-
-pdbx_struct_assembly_gen
-
-pdbx_struct_oper_list
-
-entity.id
-entity.type
-entity.pdbx_description
-
-entity_poly.entity_id
-entity_poly.pdbx_seq_one_letter_code
-entity_poly.pdbx_strand_id
-
-exptl.method
-
-refine.ls_d_res_low
-refine.ls_R_factor_R_free
-refine.ls_R_factor_R_work
-
-atom_site.pdbx_formal_charge
-atom_site.label_atom_id
-atom_site.type_symbol
-
-chem_comp.id
-chem_comp.type
-chem_comp.name
-
-chem_comp_bond
-
-atom_site.Cartn_x
-atom_site.Cartn_y
-atom_site.Cartn_z
-atom_site.B_iso_or_equiv
-atom_site.id
-atom_site.label_alt_id
-atom_site.occupancy
-atom_site.label_seq_id
-atom_site.label_comp_id
-
-struct_sheet_range.id
-struct_sheet_range.beg_label_asym_id
-struct_sheet_range.beg_label_seq_id
-struct_sheet_range.pdbx_beg_PDB_ins_code
-struct_sheet_range.end_label_asym_id
-struct_sheet_range.end_label_seq_id
-struct_sheet_range.pdbx_end_PDB_ins_code
-struct_conf.conf_type_id
-struct_conf.id
-struct_conf.beg_label_asym_id
-struct_conf.beg_label_seq_id
-struct_conf.pdbx_beg_PDB_ins_code
-struct_conf.end_label_asym_id
-struct_conf.end_label_seq_id
-struct_conf.pdbx_end_PDB_ins_code
-
-atom_site.pdbx_PDB_ins_code
-atom_site.label_asym_id
-atom_site.auth_asym_id

data/rcsb-graphql/codegen.js

@@ -0,0 +1,22 @@
+const { generate } = require('graphql-code-generator')
+const path = require('path')
+
+const basePath = path.join(__dirname, '..', '..', 'src', 'mol-model-props', 'rcsb', 'graphql')
+
+generate({
+    schema: 'http://rest-staging.rcsb.org/graphql',
+    documents: {
+        [path.join(basePath, 'symmetry.gql.ts')]: {
+            loader: path.join(__dirname, 'loader.js')
+        },
+    },
+    generates: {
+        [path.join(basePath, 'types.ts')]: {
+            plugins: ['time', 'typescript-common', 'typescript-client']
+        }
+    },
+    overwrite: true,
+    config: path.join(__dirname, 'codegen.json')
+}, true).then(
+    () => console.log('done')
+).catch(e => console.error(e))

data/rcsb-graphql/codegen.json

@@ -0,0 +1,6 @@
+{
+    "flattenTypes": true,
+    "generatorConfig": {
+        "immutableTypes": true
+    }
+}

data/rcsb-graphql/loader.js

@@ -0,0 +1,14 @@
+const { parse } = require('graphql');
+const { readFileSync } = require('fs');
+
+module.exports = function(docString, config) {
+    const str = readFileSync(docString, { encoding: 'utf-8' }).trim()
+                    .replace(/^export default `/, '')
+                    .replace(/`$/, '')
+    return [
+        {
+            filePath: docString,
+            content: parse(str)
+        }
+    ];
+};

docs/file-formats.md

@@ -1,44 +0,0 @@
-
-Support file formats and their extensions.
-
-## Structure
-
-- MMCIF and CIFCORE (mmCIF and coreCIF schemas): cif, bcif, mmcif, mcif
-- GRO: gro
-- MOL: mol
-- MOL2: mol2
-- PDB/PDBQT: pdb, ent, pdbqt
-- SDF: sdf, sd
-- XYZ: xyz
-
-
-## Topology
-
-Need to be loaded together with Coordinates.
-
-- PRMTOP: prmtop, parm7
-- PSF: psf
-- TOP: top
-
-## Coordinates
-
-Need to be loaded together with a Structure or Topology.
-
-- DCD: dcd
-- NCTRAJ: nc, nctraj
-- TRR: trr
-- XTC: xtc
-
-
-## Volume
-
-- CCP4/MRC/MAP: ccp4, mrc, map
-- CUBE (may include a Structure): cub, cube
-- DSN6/BRIX: dsn6, brix
-- DX and DXBIN: dx, dxbin
-- DSCIF (DensityServer CIF schema): cif, bcif
-
-
-## Shape
-
-- PLY

docs/interesting-pdb-entries.md

@@ -1,49 +0,0 @@
-* Cyclic polymers (1sfi, 6dny, 1HVZ)
-* B-DNA (1bna)
-* Missing carbonyl oxygen (1gfl)
-* Mono-saccharides with alt locs (1B5F)
-* Microheterogeneity
-    * Protein (1EJG, 3NIR)
-    * DNA (3VOK)
-* PNA: peptide nucleic acid (5eme, 1xj9)
-* Peptide derived residues
-    * GFP chromophores (5Z6Y)
-* Nucleotides that don’t have a parent base set, i.e. detect purine/pyrimidine from geometry (THX in 1AUL, OMC in e.g. 5D3G)
-* Bases with modified ring atoms
-    * DZ has C1 instead of N1 (e.g. 6I4N)
-    * DP has N5 instead of C5 and C7 instead of N7 (e.g. 6I4N)
-* Beta & Gamma peptides (e.g. 1GAC, 6PQF)
-* Helices of D-amino acids (e.g. 7QDI)
-* Mixed (heterogeneous) all-atom/trace-only RNA model (1JGQ)
-* Polymers with residues with missing trace atoms (e.g. 2QFJ)
-* Modified RNA bases (1y26, 5L4O)
-* Discontinuous chains, i.e. gaps in the sequence (3sn6)
-* Lots of sheets (1cbs)
-* DNA (2np2, 1d66)
-* C-alpha only (2rcj)
-* Not cyclic, but termini are backbone-only and within distance but seqIds are not compatible (6SW3)
-* Close backbone atoms but not linked (e.g. 4HIV)
-* Non-standard residues
-    * Protein (1BRR, 5Z6Y)
-    * DNA (5D3G)
-* Multiple models with different sets of ligands or missing ligands (1J6T, 1VRC, 2ICY, 1O2F)
-* Long linear sugar chain (4HG6)
-* Anisotropic B-factors/Ellipsoids (1EJG)
-* NOS bridges (LYS-CSO in 7B0L, 6ZWJ, 6ZWH)
-* Non-polymer components in polymer entities
-    * PN2 in 1F80
-    * ACE (many, e.g. 5AGU, 1E1X)
-    * ACY in 7ABY
-    * NH2 (many, e.g. 6Y13)
-* Ligands with many rings
-    * STU (e.g. 1U59) - many fused rings
-    * HT (e.g. 127D) - rings connected by a single bond
-    * J2C (e.g. 7EFJ) - rings connected by a single atom
-    * RBF (e.g. 7QF2) - three linearly fused rings
-    * TA1 (e.g. 1JFF) - many fused rings (incl. a 8-member rings)
-    * BPA (e.g. 1JDG) - many fused rings
-    * CLR (e.g. 3GKI) - four fused rings
-
-Assembly symmetries
-* 5M30 (Assembly 1, C3 local and pseudo)
-* 1RB8 (Assembly 1, I global)

docs/model-server/readme.md

@@ -6,64 +6,133 @@ Model Server is a tool for preprocessing and querying macromolecular structure d
 Installing and Running
 =====================
 
-Requires nodejs 8+.
-
-## From GitHub
-
+Getting the code (use node 8+):
 ```
 git clone https://github.com/molstar/molstar
 npm install
 ```
 
-Afterwards, build the project source:
+Customize configuration at ``src/server/model/config.ts`` to point to your data and which custom properties to include (see the [Custom Properties](#custom-properties) section). Alternatively, the config can be edited in the compiled version in ``build/node_modules/servers/model/config.js``.
+
+Afterwards, build the project:
 
 ```
-npm run build-tsc
+npm run build
 ```
 
-and run the server by 
+(or run watch mode for automatic rebuilds: ``npm run watch``)
 
+Running the server locally for testing:
 ```
-node lib/commonjs/servers/model/server/server
+npm run model-server
+```
+or
+```
+node build/node_modules/servers/model/server
 ```
 
-## From NPM
-
-```
-npm install --production molstar
-./model-server 
-```
-
-(or ``node node_modules\.bin\model-server`` in Windows).
-
-The NPM package contains all the tools mentioned here as "binaries":
-
-- ``model-server``
-- ``model-server-query``
-- ``model-server-preprocess``
+In production it is a good idea to use a service that will keep the server running, such as [forever.js](https://github.com/foreverjs/forever).
 
 
-### Production use
-
-In production it is required to use a service that will keep the server running, such as [forever.js](https://github.com/foreverjs/forever).
-
-
-### Memory issues
+## Memory issues
 
 Sometimes nodejs might run into problems with memory. This is usually resolved by adding the ``--max-old-space-size=8192`` parameter.
 
-## Preprocessor
+Preprocessor
+============
 
-The preprocessor application allows to add custom data to CIF files and/or convert CIF to BinaryCIF. ``node lib/commonjs/servers/model/preprocess`` or ``model-server-preprocess`` binary from the NPM package.
+The preprocessor application allows to add custom data to CIF files and/or convert CIF to BinaryCIF. See the [Custom Properties](#custom-properties) section for providing custom properties.
 
+## Usage
 
-## Local Mode
+The app works in two modes: single files and folders.
 
-The server can be run in local/file based mode using ``node lib/commonjs/servers/model/query`` (``model-server-query`` binary from the NPM package).
+Single files:
+
+```
+node build\node_modules\servers\model\preprocess -i input.cif [-oc output.cif] [-ob output.bcif] [--cfg config.json]
+```
+
+Folder:
+```
+node build\node_modules\servers\model\preprocess -fin input_folder [-foc output_cif_folder] [-fob output_bcif_folder] [--cfg config.json]
+```
+
+## Config
+
+The config speficies the maximum number of processes to use (in case of folder processing) and defines sources and parameters for custom properties.
+
+Example:
+```json
+{
+    "numProcesses": 4,
+    "customProperties": {
+        "sources": [
+            "./properties/pdbe"
+        ],
+        "params": {
+            "PDBe": {
+                "UseFileSource": false,
+                "API": {
+                    "residuewise_outlier_summary": "https://www.ebi.ac.uk/pdbe/api/validation/residuewise_outlier_summary/entry",
+                    "preferred_assembly": "https://www.ebi.ac.uk/pdbe/api/pdb/entry/summary",
+                    "struct_ref_domain": "https://www.ebi.ac.uk/pdbe/api/mappings/sequence_domains"
+                }
+            }
+        }
+    }
+}
+```
 
 Custom Properties
 =================
 
-This feature is still in development.
+It is possible to provide property descriptors that transform data to internal representation and define how it should be exported into one or mode CIF categories. Examples of this are located in the ``mol-model-props`` module and are linked to the server in the config and ``servers/model/properties``.
 
-It is possible to provide property descriptors that transform data to internal representation and define how it should be exported into one or mode CIF categories. Examples of this are located in the ``mol-model-props`` module and are linked to the server in the config and ``servers/model/properties``.
+Local Mode
+==========
+
+The server can be run in local/file based mode:
+
+```
+node build/node_modules/servers/model/server jobs.json
+```
+
+where ``jobs.json`` is an array of
+
+```ts
+type LocalInput = {
+    input: string,
+    output: string,
+    query: QueryName,
+    modelNums?: number[],
+    params?: any,
+    binary?: boolean
+}[]
+```
+
+For example
+
+```json
+[
+  {
+    "input": "c:/test/quick/1tqn.cif",
+    "output": "c:/test/quick/localapi/1tqn_full.cif",
+    "query": "full"
+  },
+  {
+    "input": "c:/test/quick/1tqn.cif",
+    "output": "c:/test/quick/localapi/1tqn_full.bcif",
+    "query": "full",
+    "params": {}
+  },
+  {
+    "input": "c:/test/quick/1cbs_updated.cif",
+    "output": "c:/test/quick/localapi/1cbs_ligint.cif",
+    "query": "residueInteraction",
+    "params": {
+      "atom_site": { "label_comp_id": "REA" }
+    }
+  }
+]
+```

docs/volume-server/README.md

@@ -7,64 +7,107 @@ It uses the text based CIF and BinaryCIF formats to deliver the data to the clie
 
 For quick info about the benefits of using the server, check out the [examples](examples.md).
 
-Installing and Running
+Installing the Server 
 =====================
 
-Requires nodejs 8+.
+- Install [Node.js](https://nodejs.org/en/) (tested on Node 6.* and 7.*; x64 version is strongly preferred).
+- Get the code.
+- Prepare the data.
+- Run the server.
 
-## From GitHub
-
-```
-git clone https://github.com/molstar/molstar
-npm install
-```
-
-Afterwards, build the project source:
-
-```
-npm run build-tsc
-```
-
-and run the server by 
-
-```
-node lib/commonjs/servers/volume/server
-```
-
-## From NPM
-
-```
-npm install --production molstar
-./volume-server 
-```
-
-(or ``node node_modules\.bin\volume-server`` in Windows).
-
-The NPM package contains all the tools mentioned here as "binaries":
-
-- ``volume-server``
-- ``volume-server-pack``
-- ``volume-server-query``
-
-
-### Production use
-
-In production it is required to use a service that will keep the server running, such as [forever.js](https://github.com/foreverjs/forever).
-
-
-### Memory issues
-
-Sometimes nodejs might run into problems with memory. This is usually resolved by adding the ``--max-old-space-size=8192`` parameter.
-
-
-## Preparing the Data
+Preparing the Data
+------------------
 
 For the server to work, CCP4/MAP (models 0, 1, 2 are supported) input data need to be converted into a custom block format. 
-To achieve this, use the ``pack`` application (``node lib/commonjs/servers/volume/pack`` or ``volume-server-pack`` binary from the NPM package).
+To achieve this, use the ``pack`` application.
 
-## Local Mode
+- To prepare data from x-ray based methods, use: 
 
-The program  ``lib/commonjs/servers/volume/pack`` (``volume-server-query`` in NPM package) can be used to query the data without running a http server.
+    ```
+    node pack -xray main.ccp4 diff.ccp4 out.mdb
+    ```
+
+- For EM data, use:
+
+    ```
+    node pack -em em.map out.mdb
+    ```
+
+Running the Server
+------------------
+
+- Install production dependencies:
+
+   ```
+   npm install --only=production
+   ```
+
+- Update ``server-config.js`` to link to your data and optionally tweak the other parameters.
+
+- Run it:
+
+    ```
+    node server
+    ```
+
+    In production it is a good idea to use a service that will keep the server running, such as [forever.js](https://github.com/foreverjs/forever).
+
+### Local Mode
+
+The program ``local`` in the build folder can be used to query the data without running a http server.
+
+- ``node local`` prints the program usage.
+- ``node local jobs.json`` takes a list of jobs to execute in JSON format. A job entry is defined by this interface:
+
+    ```TypeScript
+    interface JobEntry {
+        source: {
+            filename: string,    
+            name: string,
+            id: string
+        },
+        query: {
+            kind: 'box' | 'cell',
+            space?: 'fractional' | 'cartesian',
+            bottomLeft?: number[],
+            topRight?: number[],
+        }
+        params: {
+            /** Determines the detail level as specified in server-config */
+            detail?: number,
+            /** 
+             * Determines the sampling level:
+             * 1: Original data
+             * 2: Downsampled by factor 1/2
+             * ...
+             * N: downsampled 1/2^(N-1)
+             */
+            forcedSamplingLevel?: number,
+            asBinary: boolean,
+        },
+        outputFolder: string
+    }
+    ```
+
+    Example ``jobs.json`` file content:
+
+    ```TypeScript
+    [{
+        source: {
+            filename: `g:/test/mdb/emd-8116.mdb`,
+            name: 'em',
+            id: '8116',
+        },
+        query: {
+            kind: 'cell'
+        },
+        params: {
+            detail: 4,
+            asBinary: true
+        },
+        outputFolder: 'g:/test/local-test'
+    }]
+    ```
 
 ## Navigating the Source Code
 
@@ -79,8 +122,8 @@ The source code is split into 2 mains parts: ``pack`` and ``server``:
 Consuming the Data 
 ==================
 
-The data can be consumed in any (modern) browser using the [ciftools library](https://github.com/molstar/ciftools) (or any other piece of code that can read text or binary CIF).
+The data can be consumed in any (modern) browser using the [CIFTools.js library](https://github.com/dsehnal/CIFTools.js) (or any other piece of code that can read text or binary CIF).
 
 The [Data Format](DataFormat.md) document gives a detailed description of the server response format.
 
-As a reference/example of the server usage is available in Mol* ``mol-plugin`` module.
+As a reference/example of the server usage, please see the implementation in [LiteMol](https://github.com/dsehnal/LiteMol) ([CIF.ts + Data.ts](https://github.com/dsehnal/LiteMol/tree/master/src/lib/Core/Formats/Density), [UI](https://github.com/dsehnal/LiteMol/tree/master/src/Viewer/Extensions/DensityStreaming)) or in Mol*.

examples/ace2-hit.mol2

@@ -1,86 +0,0 @@
-@<TRIPOS>MOLECULE
-ace2_r_r2.top2000.poses.plain/3_Z1137565832_1_T2.pdb
- 37 41 0 0 0
-SMALL
-GASTEIGER
-
-@<TRIPOS>ATOM
-      1  C         64.7720   85.9180   38.1090 C.3     1  LIG1        0.0799
-      2  C         64.6440   84.6900   37.1570 C.3     1  LIG1        0.0306
-      3  C         65.2660   83.4260   37.8080 C.3     1  LIG1        0.0927
-      4  N         66.6560   83.6710   38.1790 N.pl3   1  LIG1       -0.2919
-      5  C         67.7080   82.9280   37.6260 C.ar    1  LIG1        0.1520
-      6  C         69.0970   83.1860   37.8250 C.ar    1  LIG1        0.0393
-      7  C         70.0830   82.4100   37.1810 C.ar    1  LIG1        0.0436
-      8  C         69.6450   81.3740   36.3510 C.ar    1  LIG1        0.1867
-      9  N         70.3370   80.5030   35.6050 N.ar    1  LIG1       -0.1270
-     10  N         69.4700   79.7480   35.0040 N.ar    1  LIG1       -0.1228
-     11  C         68.2200   80.1120   35.3570 C.ar    1  LIG1        0.2583
-     12  N         68.3350   81.1470   36.2040 N.ar    1  LIG1       -0.1866
-     13  N         67.4230   81.8700   36.8030 N.ar    1  LIG1       -0.1473
-     14  C         66.8190   84.7600   39.1350 C.3     1  LIG1        0.0927
-     15  C         66.2560   86.0870   38.5570 C.3     1  LIG1        0.0306
-     16  N         64.4520   87.4670   36.2150 N.am    1  LIG1       -0.2979
-     17  H         64.9740   86.7650   35.7110 H       1  LIG1        0.1498
-     18  C         64.2290   87.1720   37.5220 C.2     1  LIG1        0.2224
-     19  O         63.5690   87.9550   38.2480 O.2     1  LIG1       -0.2751
-     20  C         64.0160   88.6470   35.5420 C.3     1  LIG1        0.1559
-     21  C         65.9650   88.2170   32.5700 C.ar    1  LIG1        0.1629
-     22  N         65.8040   88.0390   33.8860 N.ar    1  LIG1       -0.3232
-     23  H         66.4190   87.5270   34.5040 H       1  LIG1        0.1686
-     24  C         64.6770   88.6690   34.2330 C.ar    1  LIG1        0.1601
-     25  N         64.1890   89.2810   33.1430 N.ar    1  LIG1       -0.1318
-     26  N         64.9640   89.0070   32.1450 N.ar    1  LIG1       -0.1293
-     27  F         69.9260   86.0280   29.3520 F       1  LIG1       -0.2042
-     28  C         68.9880   86.5420   30.0990 C.ar    1  LIG1        0.1401
-     29  C         67.6590   86.0900   29.9830 C.ar    1  LIG1        0.0297
-     30  C         66.6500   86.6450   30.7950 C.ar    1  LIG1        0.0053
-     31  C         66.9590   87.6470   31.7450 C.ar    1  LIG1        0.0359
-     32  C         68.2970   88.0990   31.8400 C.ar    1  LIG1        0.0053
-     33  C         69.3030   87.5560   31.0230 C.ar    1  LIG1        0.0297
-     34  C         66.9850   79.4910   34.8440 C.3     1  LIG1        0.4541
-     35  F         67.3150   78.4110   34.0640 F       1  LIG1       -0.1631
-     36  F         66.2460   80.3690   34.0910 F       1  LIG1       -0.1631
-     37  F         66.1920   79.0650   35.8800 F       1  LIG1       -0.1631
-@<TRIPOS>BOND
-     1     1     2    1
-     2     1    18    1
-     3     1    15    1
-     4     2     3    1
-     5     3     4    1
-     6     4     5    1
-     7     4    14    1
-     8     5    13   ar
-     9     5     6   ar
-    10     6     7   ar
-    11     7     8   ar
-    12     8     9   ar
-    13     8    12   ar
-    14     9    10   ar
-    15    10    11   ar
-    16    11    34    1
-    17    11    12   ar
-    18    12    13   ar
-    19    14    15    1
-    20    16    20    1
-    21    16    17    1
-    22    16    18   am
-    23    18    19    2
-    24    20    24    1
-    25    21    31    1
-    26    21    26   ar
-    27    21    22   ar
-    28    22    24   ar
-    29    22    23    1
-    30    24    25   ar
-    31    25    26   ar
-    32    27    28    1
-    33    28    29   ar
-    34    28    33   ar
-    35    29    30   ar
-    36    30    31   ar
-    37    31    32   ar
-    38    32    33   ar
-    39    34    35    1
-    40    34    36    1
-    41    34    37    1

package.json

@@ -1,6 +1,6 @@
 {
   "name": "molstar",
-  "version": "3.23.0",
+  "version": "0.4.5",
   "description": "A comprehensive macromolecular library.",
   "homepage": "https://github.com/molstar/molstar#readme",
   "repository": {
@@ -11,50 +11,27 @@
     "url": "https://github.com/molstar/molstar/issues"
   },
   "scripts": {
-    "lint": "eslint .",
-    "lint-fix": "eslint . --fix",
-    "test": "npm install --no-save \"gl@^5.0.0\" && npm run lint && jest",
-    "jest": "jest",
+    "lint": "tslint src/**/*.ts",
+    "test": "npm run lint && jest",
     "build": "npm run build-tsc && npm run build-extra && npm run build-webpack",
-    "clean": "node ./scripts/clean.js",
-    "rebuild": "npm run clean && npm run build",
-    "build-viewer": "npm run build-tsc && npm run build-extra && npm run build-webpack-viewer",
-    "build-tsc": "concurrently \"tsc --incremental\" \"tsc --build tsconfig.commonjs.json --incremental\"",
-    "build-extra": "cpx \"src/**/*.{scss,html,ico,jpg}\" lib/",
-    "build-webpack": "webpack --mode production --config ./webpack.config.production.js",
-    "build-webpack-viewer": "webpack --mode production --config ./webpack.config.viewer.js",
-    "watch": "concurrently -c \"green,green,gray,gray\" --names \"tsc,srv,ext,wpc\" --kill-others \"npm:watch-tsc\" \"npm:watch-servers\" \"npm:watch-extra\" \"npm:watch-webpack\"",
-    "watch-viewer": "concurrently -c \"green,gray,gray\" --names \"tsc,ext,wpc\" --kill-others \"npm:watch-tsc\" \"npm:watch-extra\" \"npm:watch-webpack-viewer\"",
-    "watch-viewer-debug": "concurrently -c \"green,gray,gray\" --names \"tsc,ext,wpc\" --kill-others \"npm:watch-tsc\" \"npm:watch-extra\" \"npm:watch-webpack-viewer-debug\"",
-    "watch-tsc": "tsc --watch --incremental",
-    "watch-servers": "tsc --build tsconfig.commonjs.json --watch --incremental",
-    "watch-extra": "cpx \"src/**/*.{scss,html,ico,jpg}\" lib/ --watch",
-    "watch-webpack": "webpack -w --mode development --stats minimal",
-    "watch-webpack-viewer": "webpack -w --mode development --stats minimal --config ./webpack.config.viewer.js",
-    "watch-webpack-viewer-debug": "webpack -w --mode development --stats minimal --config ./webpack.config.viewer.debug.js",
-    "serve": "http-server -p 1338 -g",
-    "model-server": "node lib/commonjs/servers/model/server.js",
-    "model-server-watch": "nodemon --watch lib lib/commonjs/servers/model/server.js",
-    "volume-server-test": "node lib/commonjs/servers/volume/server.js --idMap em 'test/${id}.mdb' --defaultPort 1336",
-    "plugin-state": "node lib/commonjs/servers/plugin-state/index.js --working-folder ./build/state --port 1339",
+    "build-tsc": "tsc",
+    "build-extra": "cpx \"src/**/*.{scss,woff,woff2,ttf,otf,eot,svg,html,ico}\" lib/",
+    "build-webpack": "webpack --mode production",
+    "watch": "concurrently --kill-others \"npm:watch-tsc\" \"npm:watch-extra\" \"npm:watch-webpack\"",
+    "watch-tsc": "tsc -watch",
+    "watch-extra": "cpx \"src/**/*.{scss,woff,woff2,ttf,otf,eot,svg,html,ico}\" lib/ --watch",
+    "watch-webpack": "webpack -w --mode development --display minimal",
+    "serve": "http-server -p 1338",
+    "model-server": "node lib/servers/model/server.js",
+    "model-server-watch": "nodemon --watch lib lib/servers/model/server.js",
+    "volume-server": "node lib/servers/volume/server.js --idMap em 'test/${id}.mdb' --defaultPort  1336",
     "preversion": "npm run test",
-    "version": "npm run rebuild && cpx .npmignore lib/",
-    "postversion": "git push && git push --tags"
+    "postversion": "git push && git push --tags",
+    "prepublishOnly": "npm run test && npm run build"
   },
   "files": [
-    "lib/",
-    "build/viewer/"
+    "lib/"
   ],
-  "bin": {
-    "cif2bcif": "lib/commonjs/cli/cif2bcif/index.js",
-    "cifschema": "lib/commonjs/cli/cifschema/index.js",
-    "model-server": "lib/commonjs/servers/model/server.js",
-    "model-server-query": "lib/commonjs/servers/model/query.js",
-    "model-server-preprocess": "lib/commonjs/servers/model/preprocess.js",
-    "volume-server": "lib/commonjs/servers/volume/server.js",
-    "volume-server-query": "lib/commonjs/servers/volume/query.js",
-    "volume-server-pack": "lib/commonjs/servers/volume/pack.js"
-  },
   "nodemonConfig": {
     "ignoreRoot": [
       "./node_modules",
@@ -75,93 +52,66 @@
       "node_modules",
       "lib"
     ],
-    "testEnvironmentOptions": {
-      "url": "http://localhost/"
-    },
+    "testURL": "http://localhost/",
     "testRegex": "\\.spec\\.ts$"
   },
   "author": "Mol* Contributors",
   "contributors": [
     "Alexander Rose <alexander.rose@weirdbyte.de>",
     "David Sehnal <david.sehnal@gmail.com>",
-    "Sebastian Bittrich <sebastian.bittrich@rcsb.org>",
-    "Áron Samuel Kovács <aron.kovacs@mail.muni.cz>",
-    "Ludovic Autin <autin@scripps.edu>",
-    "Michal Malý <michal.maly@ibt.cas.cz>",
-    "Jiří Černý <jiri.cerny@ibt.cas.cz>",
-    "Panagiotis Tourlas <panagiot_tourlov@hotmail.com>",
-    "Adam Midlik <midlik@gmail.com>",
-    "Koya Sakuma <koya.sakuma.work@gmail.com>",
-    "Gianluca Tomasello <giagitom@gmail.com>"
+    "Sebastian Bittrich <sebastian.bittrich@rcsb.org>"
   ],
   "license": "MIT",
   "devDependencies": {
-    "@graphql-codegen/add": "^3.2.1",
-    "@graphql-codegen/cli": "^2.13.7",
-    "@graphql-codegen/time": "^3.2.1",
-    "@graphql-codegen/typescript": "^2.7.4",
-    "@graphql-codegen/typescript-graphql-files-modules": "^2.2.1",
-    "@graphql-codegen/typescript-graphql-request": "^4.5.6",
-    "@graphql-codegen/typescript-operations": "^2.5.4",
-    "@types/cors": "^2.8.12",
-    "@types/gl": "^4.1.1",
-    "@types/jest": "^29.1.2",
-    "@types/react": "^18.0.21",
-    "@types/react-dom": "^18.0.6",
-    "@typescript-eslint/eslint-plugin": "^5.40.0",
-    "@typescript-eslint/parser": "^5.40.0",
     "benchmark": "^2.1.4",
-    "concurrently": "^7.4.0",
-    "cpx2": "^4.2.0",
-    "crypto-browserify": "^3.12.0",
-    "css-loader": "^6.7.1",
-    "eslint": "^8.25.0",
+    "circular-dependency-plugin": "^5.2.0",
+    "concurrently": "^5.0.0",
+    "cpx": "^1.5.0",
+    "css-loader": "^3.2.0",
     "extra-watch-webpack-plugin": "^1.0.3",
-    "file-loader": "^6.2.0",
-    "fs-extra": "^10.1.0",
-    "graphql": "^16.6.0",
-    "http-server": "^14.1.1",
-    "jest": "^29.2.0",
-    "mini-css-extract-plugin": "^2.6.1",
-    "path-browserify": "^1.0.1",
-    "raw-loader": "^4.0.2",
-    "react": "^18.2.0",
-    "react-dom": "^18.2.0",
-    "sass": "^1.55.0",
-    "sass-loader": "^13.1.0",
-    "simple-git": "^3.14.1",
-    "stream-browserify": "^3.0.0",
-    "style-loader": "^3.3.1",
-    "ts-jest": "^29.0.3",
-    "typescript": "^4.8.4",
-    "webpack": "^5.74.0",
-    "webpack-cli": "^4.10.0"
+    "file-loader": "^4.2.0",
+    "fs-extra": "^8.1.0",
+    "graphql-code-generator": "^0.18.2",
+    "graphql-codegen-time": "^0.18.2",
+    "graphql-codegen-typescript-template": "^0.18.2",
+    "http-server": "^0.11.1",
+    "jest": "^24.9.0",
+    "jest-raw-loader": "^1.0.1",
+    "mini-css-extract-plugin": "^0.8.0",
+    "node-sass": "^4.13.0",
+    "raw-loader": "^3.1.0",
+    "resolve-url-loader": "^3.1.1",
+    "sass-loader": "^8.0.0",
+    "simple-git": "^1.126.0",
+    "style-loader": "^1.0.0",
+    "ts-jest": "^24.1.0",
+    "tslint": "^5.20.1",
+    "typescript": "^3.7.2",
+    "webpack": "^4.41.2",
+    "webpack-cli": "^3.3.10"
   },
   "dependencies": {
-    "@types/argparse": "^2.0.10",
-    "@types/benchmark": "^2.1.2",
-    "@types/compression": "1.7.2",
-    "@types/express": "^4.17.14",
-    "@types/node": "^16.11.66",
-    "@types/node-fetch": "^2.6.2",
-    "@types/swagger-ui-dist": "3.30.1",
-    "argparse": "^2.0.1",
-    "body-parser": "^1.20.1",
+    "@types/argparse": "^1.0.36",
+    "@types/benchmark": "^1.0.31",
+    "@types/compression": "1.0.1",
+    "@types/express": "^4.17.2",
+    "@types/jest": "^24.0.23",
+    "@types/node": "^12.12.9",
+    "@types/node-fetch": "^2.5.3",
+    "@types/react": "^16.9.11",
+    "@types/react-dom": "^16.9.4",
+    "@types/swagger-ui-dist": "3.0.3",
+    "argparse": "^1.0.10",
     "compression": "^1.7.4",
-    "cors": "^2.8.5",
-    "express": "^4.18.2",
-    "h264-mp4-encoder": "^1.0.12",
-    "immer": "^9.0.15",
-    "immutable": "^4.1.0",
-    "node-fetch": "^2.6.7",
-    "rxjs": "^7.5.7",
-    "swagger-ui-dist": "^4.14.3",
-    "tslib": "^2.4.0",
-    "util.promisify": "^1.1.1",
-    "xhr2": "^0.2.1"
-  },
-  "peerDependencies": {
-    "react": "^18.1.0 || ^17.0.2 || ^16.14.0",
-    "react-dom": "^18.1.0 || ^17.0.2 || ^16.14.0"
+    "express": "^4.17.1",
+    "graphql": "^14.5.8",
+    "immutable": "^3.8.2",
+    "node-fetch": "^2.6.0",
+    "react": "^16.12.0",
+    "react-dom": "^16.12.0",
+    "rxjs": "^6.5.3",
+    "swagger-ui-dist": "^3.24.3",
+    "util.promisify": "^1.0.0",
+    "xhr2": "^0.2.0"
   }
 }

scripts/clean.js

@@ -1,41 +0,0 @@
-/**
- * Copyright (c) 2021 mol* contributors, licensed under MIT, See LICENSE file for more info.
- *
- * @author Michal Malý <malym@ibt.cas.cz>
- */
-
-const fs = require('fs');
-const path = require('path');
-
-function removeDir(dirPath) {
-    for (const ent of fs.readdirSync(dirPath)) {
-        const entryPath = path.join(dirPath, ent);
-        remove(entryPath);
-    }
-
-    fs.rmdirSync(dirPath);
-}
-
-function remove(entryPath) {
-    const st = fs.statSync(entryPath);
-    if (st.isDirectory())
-        removeDir(entryPath);
-    else
-        fs.unlinkSync(entryPath);
-}
-
-const toClean = [
-    path.resolve(__dirname, '../build'),
-    path.resolve(__dirname, '../lib'),
-    path.resolve(__dirname, '../tsconfig.tsbuildinfo'),
-];
-
-toClean.forEach(ph => {
-    if (fs.existsSync(ph)) {
-        try {
-            remove(ph);
-        } catch (err) {
-            console.warn(`Cleanup failed: ${err}`);
-        }
-    }
-});

scripts/deploy.js

@@ -1,87 +1,59 @@
 /**
- * Copyright (c) 2019-2021 mol* contributors, licensed under MIT, See LICENSE file for more info.
+ * Copyright (c) 2019 mol* contributors, licensed under MIT, See LICENSE file for more info.
  *
  * @author Alexander Rose <alexander.rose@weirdbyte.de>
  */
 
-const git = require('simple-git');
-const path = require('path');
-const fs = require("fs");
-const fse = require("fs-extra");
+const git = require('simple-git')
+const path = require('path')
+const fs = require("fs")
+const fse = require("fs-extra")
 
-const remoteUrl = "https://github.com/molstar/molstar.github.io.git";
-const buildDir = path.resolve(__dirname, '../build/');
-const deployDir = path.resolve(buildDir, 'deploy/');
-const localPath = path.resolve(deployDir, 'molstar.github.io/');
-
-const analyticsTag = /<!-- __MOLSTAR_ANALYTICS__ -->/g;
-const analyticsCode = `<!-- Cloudflare Web Analytics --><script defer src='https://static.cloudflareinsights.com/beacon.min.js' data-cf-beacon='{"token": "c414cbae2d284ea995171a81e4a3e721"}'></script><!-- End Cloudflare Web Analytics -->`;
+const remoteUrl = "https://github.com/molstar/molstar.github.io.git"
+const buildDir = path.resolve(__dirname, '../build/')
+const deployDir = path.resolve(buildDir, 'deploy/')
+const localPath = path.resolve(deployDir, 'molstar.github.io/')
 
 function log(command, stdout, stderr) {
     if (command) {
-        console.log('\n###', command);
-        stdout.pipe(process.stdout);
-        stderr.pipe(process.stderr);
+        console.log('\n###', command)
+        stdout.pipe(process.stdout)
+        stderr.pipe(process.stderr)
     }
 }
 
-function addAnalytics(path) {
-    const data = fs.readFileSync(path, 'utf8');
-    const result = data.replace(analyticsTag, analyticsCode);
-    fs.writeFileSync(path, result, 'utf8');
-}
-
 function copyViewer() {
-    console.log('\n###', 'copy viewer files');
-    const viewerBuildPath = path.resolve(buildDir, '../build/viewer/');
-    const viewerDeployPath = path.resolve(localPath, 'viewer/');
-    fse.copySync(viewerBuildPath, viewerDeployPath, { overwrite: true });
-    addAnalytics(path.resolve(viewerDeployPath, 'index.html'));
-}
-
-function copyDemos() {
-    console.log('\n###', 'copy demos files');
-    const lightingBuildPath = path.resolve(buildDir, '../build/examples/lighting/');
-    const lightingDeployPath = path.resolve(localPath, 'demos/lighting/');
-    fse.copySync(lightingBuildPath, lightingDeployPath, { overwrite: true });
-    addAnalytics(path.resolve(lightingDeployPath, 'index.html'));
-
-    const orbitalsBuildPath = path.resolve(buildDir, '../build/examples/alpha-orbitals/');
-    const orbitalsDeployPath = path.resolve(localPath, 'demos/alpha-orbitals/');
-    fse.copySync(orbitalsBuildPath, orbitalsDeployPath, { overwrite: true });
-    addAnalytics(path.resolve(orbitalsDeployPath, 'index.html'));
-}
-
-function copyFiles() {
-    copyViewer();
-    copyDemos();
+    console.log('\n###', 'copy viewer files')
+    const viewerBuildPath = path.resolve(buildDir, '../build/viewer/')
+    const viewerDeployPath = path.resolve(localPath, 'viewer/')
+    fse.copySync(viewerBuildPath, viewerDeployPath, { overwrite: true })
 }
 
 if (!fs.existsSync(localPath)) {
-    console.log('\n###', 'create localPath');
-    fs.mkdirSync(localPath, { recursive: true });
+    console.log('\n###', 'create localPath')
+    fs.mkdirSync(localPath, { recursive: true })
 }
 
 process.chdir(localPath);
 
 if (!fs.existsSync(path.resolve(localPath, '.git/'))) {
-    console.log('\n###', 'clone repository');
+    console.log('\n###', 'clone repository')
     git()
         .outputHandler(log)
         .clone(remoteUrl, localPath)
         .fetch(['--all'])
-        .exec(copyFiles)
+        .exec(copyViewer)
         .add(['-A'])
-        .commit('updated viewer & demos')
-        .push();
+        .commit('updated viewer')
+        .push()
 } else {
-    console.log('\n###', 'update repository');
+    console.log('\n###', 'update repository')
     git()
         .outputHandler(log)
         .fetch(['--all'])
         .reset(['--hard', 'origin/master'])
-        .exec(copyFiles)
+        .exec(copyViewer)
         .add(['-A'])
-        .commit('updated viewer & demos')
-        .push();
+        .commit('updated viewer')
+        .push()
 }

src/apps/basic-wrapper/coloring.ts

@@ -1,8 +1,7 @@
 /**
- * Copyright (c) 2019-2020 mol* contributors, licensed under MIT, See LICENSE file for more info.
+ * Copyright (c) 2019 mol* contributors, licensed under MIT, See LICENSE file for more info.
  *
  * @author David Sehnal <david.sehnal@gmail.com>
- * @author Alexander Rose <alexander.rose@weirdbyte.de>
  */
 
 import { CustomElementProperty } from '../../mol-model-props/common/custom-element-property';
@@ -10,21 +9,22 @@ import { Model, ElementIndex } from '../../mol-model/structure';
 import { Color } from '../../mol-util/color';
 
 export const StripedResidues = CustomElementProperty.create<number>({
-    label: 'Residue Stripes',
+    isStatic: true,
     name: 'basic-wrapper-residue-striping',
+    display: 'Residue Stripes',
     getData(model: Model) {
         const map = new Map<ElementIndex, number>();
         const residueIndex = model.atomicHierarchy.residueAtomSegments.index;
         for (let i = 0, _i = model.atomicHierarchy.atoms._rowCount; i < _i; i++) {
             map.set(i as ElementIndex, residueIndex[i] % 2);
         }
-        return { value: map };
+        return map;
     },
     coloring: {
-        getColor(e) { return e === 0 ? Color(0xff0000) : Color(0x0000ff); },
+        getColor(e) { return e === 0 ? Color(0xff0000) : Color(0x0000ff) },
         defaultColor: Color(0x777777)
     },
-    getLabel(e) {
-        return e === 0 ? 'Odd stripe' : 'Even stripe';
+    format(e) {
+        return e === 0 ? 'Odd stripe' : 'Even stripe'
     }
-});
+})

src/apps/basic-wrapper/controls.tsx

@@ -0,0 +1,30 @@
+/**
+ * Copyright (c) 2019 mol* contributors, licensed under MIT, See LICENSE file for more info.
+ *
+ * @author David Sehnal <david.sehnal@gmail.com>
+ */
+
+import { PluginUIComponent } from '../../mol-plugin/ui/base';
+import * as React from 'react';
+import { TransformUpdaterControl } from '../../mol-plugin/ui/state/update-transform';
+
+export class BasicWrapperControls extends PluginUIComponent {
+
+    render() {
+        return <div style={{ overflowY: 'auto', display: 'block', height: '100%' }}>
+            <TransformUpdaterControl nodeRef='asm' />
+            <TransformUpdaterControl nodeRef='seq-visual' header={{ name: 'Sequence Visual' }} />
+            <TransformUpdaterControl nodeRef='het-visual' header={{ name: 'HET Visual' }} />
+            <TransformUpdaterControl nodeRef='water-visual' header={{ name: 'Water Visual' }} initiallyCollapsed={true} />
+            <TransformUpdaterControl nodeRef='ihm-visual' header={{ name: 'I/HM Visual' }} initiallyCollapsed={true} />
+        </div>;
+    }
+}
+
+export class CustomToastMessage extends PluginUIComponent {
+    render() {
+        return <>
+            Custom <i>Toast</i> content. No timeout.
+        </>;
+    }
+}

src/apps/basic-wrapper/helpers.ts

@@ -0,0 +1,94 @@
+/**
+ * Copyright (c) 2019 mol* contributors, licensed under MIT, See LICENSE file for more info.
+ *
+ * @author David Sehnal <david.sehnal@gmail.com>
+ */
+
+import { Mat4, Vec3 } from '../../mol-math/linear-algebra';
+import { PluginContext } from '../../mol-plugin/context';
+import { PluginStateObject as PSO } from '../../mol-plugin/state/objects';
+import { StateTransforms } from '../../mol-plugin/state/transforms';
+import { StructureRepresentation3DHelpers } from '../../mol-plugin/state/transforms/representation';
+import { MolScriptBuilder as MS } from '../../mol-script/language/builder';
+import { StateBuilder } from '../../mol-state';
+import Expression from '../../mol-script/language/expression';
+import { BuiltInColorThemeName } from '../../mol-theme/color';
+type SupportedFormats = 'cif' | 'pdb'
+
+export namespace StateHelper {
+    export function download(b: StateBuilder.To<PSO.Root>, url: string, ref?: string) {
+        return b.apply(StateTransforms.Data.Download, { url, isBinary: false }, { ref });
+    }
+
+    export function getModel(b: StateBuilder.To<PSO.Data.Binary | PSO.Data.String>, format: SupportedFormats, modelIndex = 0) {
+        const parsed = format === 'cif'
+            ? b.apply(StateTransforms.Data.ParseCif).apply(StateTransforms.Model.TrajectoryFromMmCif)
+            : b.apply(StateTransforms.Model.TrajectoryFromPDB);
+
+        return parsed.apply(StateTransforms.Model.ModelFromTrajectory, { modelIndex });
+    }
+
+    export function structure(b: StateBuilder.To<PSO.Molecule.Model>) {
+        return b.apply(StateTransforms.Model.StructureFromModel, { tags: 'structure' })
+    };
+
+    export function selectChain(b: StateBuilder.To<PSO.Molecule.Structure>, auth_asym_id: string) {
+        const expression = MS.struct.generator.atomGroups({
+            'chain-test': MS.core.rel.eq([MS.struct.atomProperty.macromolecular.auth_asym_id(), auth_asym_id])
+        })
+        return b.apply(StateTransforms.Model.StructureSelectionFromExpression, { expression, label: `Chain ${auth_asym_id}` });
+    }
+
+    export function select(b: StateBuilder.To<PSO.Molecule.Structure>, expression: Expression) {
+        return b.apply(StateTransforms.Model.StructureSelectionFromExpression, { expression });
+    }
+
+    export function selectSurroundingsOfFirstResidue(b: StateBuilder.To<PSO.Molecule.Structure>, comp_id: string, radius: number) {
+        const expression = MS.struct.modifier.includeSurroundings({
+            0: MS.struct.filter.first([
+                MS.struct.generator.atomGroups({
+                    'residue-test': MS.core.rel.eq([MS.struct.atomProperty.macromolecular.label_comp_id(), comp_id]),
+                    'group-by': MS.struct.atomProperty.macromolecular.residueKey()
+                })
+            ]),
+            radius
+        })
+        return b.apply(StateTransforms.Model.StructureSelectionFromExpression, { expression, label: `Surr. ${comp_id} (${radius} ang)` });
+    }
+
+    export function identityTransform(b: StateBuilder.To<PSO.Molecule.Structure>, m: Mat4) {
+        return b.apply(StateTransforms.Model.TransformStructureConformation,
+            { axis: Vec3.create(1, 0, 0), angle: 0, translation: Vec3.zero() },
+            { tags: 'transform' });
+    }
+
+    export function transform(b: StateBuilder.To<PSO.Molecule.Structure>, matrix: Mat4) {
+        return b.apply(StateTransforms.Model.TransformStructureConformationByMatrix, { matrix }, { tags: 'transform' });
+    }
+
+    export function assemble(b: StateBuilder.To<PSO.Molecule.Model>, id?: string) {
+        return b.apply(StateTransforms.Model.StructureAssemblyFromModel, { id: id || 'deposited' }, { tags: 'asm' })
+    }
+
+    export function visual(ctx: PluginContext, visualRoot: StateBuilder.To<PSO.Molecule.Structure>) {
+        visualRoot.apply(StateTransforms.Model.StructureComplexElement, { type: 'atomic-sequence' })
+            .apply(StateTransforms.Representation.StructureRepresentation3D,
+                StructureRepresentation3DHelpers.getDefaultParamsStatic(ctx, 'cartoon'), { tags: 'seq-visual' });
+        visualRoot.apply(StateTransforms.Model.StructureComplexElement, { type: 'atomic-het' })
+            .apply(StateTransforms.Representation.StructureRepresentation3D,
+                StructureRepresentation3DHelpers.getDefaultParamsStatic(ctx, 'ball-and-stick'), { tags: 'het-visual' });
+        // visualRoot.apply(StateTransforms.Model.StructureComplexElement, { type: 'water' })
+        //     .apply(StateTransforms.Representation.StructureRepresentation3D,
+        //         StructureRepresentation3DHelpers.getDefaultParamsStatic(ctx, 'ball-and-stick', { alpha: 0.51 }), { tags: 'water-visual' });
+        return visualRoot;
+    }
+
+    export function ballsAndSticks(ctx: PluginContext, visualRoot: StateBuilder.To<PSO.Molecule.Structure>, expression: Expression, coloring?: BuiltInColorThemeName) {
+        visualRoot
+            .apply(StateTransforms.Model.StructureSelectionFromExpression, { expression })
+            .apply(StateTransforms.Representation.StructureRepresentation3D,
+                StructureRepresentation3DHelpers.getDefaultParamsStatic(ctx, 'ball-and-stick', void 0, coloring), { tags: 'het-visual' });
+        return visualRoot;
+    }
+
+}

src/apps/basic-wrapper/index.html

@@ -41,7 +41,7 @@
                 display: block;
             }
         </style>
-        <link rel="stylesheet" type="text/css" href="molstar.css" />
+        <link rel="stylesheet" type="text/css" href="app.css" />
         <script type="text/javascript" src="./index.js"></script>
     </head>
     <body>
@@ -50,18 +50,18 @@
             <input type='text' id='url' placeholder='url' />
             <input type='text' id='assemblyId' placeholder='assembly id' />
             <select id='format'>
-                <option value='mmcif' selected>mmCIF</option>
+                <option value='cif' selected>CIF</option>
                 <option value='pdb'>PDB</option>
             </select>
         </div>
         <div id="app"></div>
-        <script>
+        <script>      
             function $(id) { return document.getElementById(id); }
-
+        
             var pdbId = '1grm', assemblyId= '1';
             var url = 'https://www.ebi.ac.uk/pdbe/static/entry/' + pdbId + '_updated.cif';
-            var format = 'mmcif';
-
+            var format = 'cif';
+            
             $('url').value = url;
             $('url').onchange = function (e) { url = e.target.value; }
             $('assemblyId').value = assemblyId;
@@ -69,9 +69,15 @@
             $('format').value = format;
             $('format').onchange = function (e) { format = e.target.value; }
 
-            BasicMolStarWrapper.init('app' /** or document.getElementById('app') */).then(() => {
-                BasicMolStarWrapper.setBackground(0xffffff);
-            });
+            // var url = 'https://www.ebi.ac.uk/pdbe/entry-files/pdb' + pdbId + '.ent';
+            // var format = 'pdb';
+            // var assemblyId = 'deposited';
+
+            BasicMolStarWrapper.init('app' /** or document.getElementById('app') */);
+            BasicMolStarWrapper.setBackground(0xffffff);
+            // BasicMolStarWrapper.load({ url: url, format: format, assemblyId: assemblyId });
+            // BasicMolStarWrapper.toggleSpin();
+
 
             addControl('Load Asym Unit', () => BasicMolStarWrapper.load({ url: url, format: format }));
             addControl('Load Assembly', () => BasicMolStarWrapper.load({ url: url, format: format, assemblyId: assemblyId }));
@@ -80,14 +86,14 @@
 
             addHeader('Camera');
             addControl('Toggle Spin', () => BasicMolStarWrapper.toggleSpin());
-
+            
             addSeparator();
 
             addHeader('Animation');
 
             // adjust this number to make the animation faster or slower
             // requires to "restart" the animation if changed
-            BasicMolStarWrapper.animate.modelIndex.targetFps = 30;
+            BasicMolStarWrapper.animate.modelIndex.maxFPS = 30;
 
             addControl('Play To End', () => BasicMolStarWrapper.animate.modelIndex.onceForward());
             addControl('Play To Start', () => BasicMolStarWrapper.animate.modelIndex.onceBackward());
@@ -98,8 +104,6 @@
             addHeader('Misc');
 
             addControl('Apply Stripes', () => BasicMolStarWrapper.coloring.applyStripes());
-            addControl('Apply Custom Theme', () => BasicMolStarWrapper.coloring.applyCustomTheme());
-            addControl('Default Coloring', () => BasicMolStarWrapper.coloring.applyDefault());
 
             addHeader('Interactivity');
             addControl('Highlight seq_id=7', () => BasicMolStarWrapper.interactivity.highlightOn());
@@ -110,7 +114,7 @@
             addControl('Static Superposition', () => BasicMolStarWrapper.tests.staticSuperposition());
             addControl('Dynamic Superposition', () => BasicMolStarWrapper.tests.dynamicSuperposition());
             addControl('Validation Tooltip', () => BasicMolStarWrapper.tests.toggleValidationTooltip());
-
+            
             addControl('Show Toasts', () => BasicMolStarWrapper.tests.showToasts());
             addControl('Hide Toasts', () => BasicMolStarWrapper.tests.hideToasts());
 

src/apps/basic-wrapper/index.ts

@@ -0,0 +1,201 @@
+/**
+ * Copyright (c) 2019 mol* contributors, licensed under MIT, See LICENSE file for more info.
+ *
+ * @author David Sehnal <david.sehnal@gmail.com>
+ */
+
+import { createPlugin, DefaultPluginSpec } from '../../mol-plugin';
+import './index.html'
+import { PluginContext } from '../../mol-plugin/context';
+import { PluginCommands } from '../../mol-plugin/command';
+import { StateTransforms } from '../../mol-plugin/state/transforms';
+import { StructureRepresentation3DHelpers } from '../../mol-plugin/state/transforms/representation';
+import { Color } from '../../mol-util/color';
+import { PluginStateObject as PSO, PluginStateObject } from '../../mol-plugin/state/objects';
+import { AnimateModelIndex } from '../../mol-plugin/state/animation/built-in';
+import { StateBuilder, StateTransform } from '../../mol-state';
+import { StripedResidues } from './coloring';
+import { StaticSuperpositionTestData, buildStaticSuperposition, dynamicSuperpositionTest } from './superposition';
+import { PDBeStructureQualityReport } from '../../mol-plugin/behavior/dynamic/custom-props';
+import { CustomToastMessage } from './controls';
+import { EmptyLoci } from '../../mol-model/loci';
+import { StructureSelection } from '../../mol-model/structure';
+import { Script } from '../../mol-script/script';
+require('mol-plugin/skin/light.scss')
+
+type SupportedFormats = 'cif' | 'pdb'
+type LoadParams = { url: string, format?: SupportedFormats, assemblyId?: string }
+
+class BasicWrapper {
+    plugin: PluginContext;
+
+    init(target: string | HTMLElement) {
+        this.plugin = createPlugin(typeof target === 'string' ? document.getElementById(target)! : target, {
+            ...DefaultPluginSpec,
+            layout: {
+                initial: {
+                    isExpanded: false,
+                    showControls: false
+                },
+                controls: {
+                    // left: 'none',
+                    // right: BasicWrapperControls
+                }
+            }
+        });
+
+        this.plugin.structureRepresentation.themeCtx.colorThemeRegistry.add(StripedResidues.Descriptor.name, StripedResidues.colorTheme!);
+        this.plugin.lociLabels.addProvider(StripedResidues.labelProvider);
+        this.plugin.customModelProperties.register(StripedResidues.propertyProvider);
+    }
+
+    private download(b: StateBuilder.To<PSO.Root>, url: string) {
+        return b.apply(StateTransforms.Data.Download, { url, isBinary: false })
+    }
+
+    private parse(b: StateBuilder.To<PSO.Data.Binary | PSO.Data.String>, format: SupportedFormats, assemblyId: string) {
+        const parsed = format === 'cif'
+            ? b.apply(StateTransforms.Data.ParseCif).apply(StateTransforms.Model.TrajectoryFromMmCif)
+            : b.apply(StateTransforms.Model.TrajectoryFromPDB);
+
+        return parsed
+            .apply(StateTransforms.Model.ModelFromTrajectory, { modelIndex: 0 })
+            .apply(StateTransforms.Model.CustomModelProperties, { properties: [StripedResidues.Descriptor.name] }, { ref: 'props', state: { isGhost: false } })
+            .apply(StateTransforms.Model.StructureAssemblyFromModel, { id: assemblyId || 'deposited' }, { ref: 'asm' });
+    }
+
+    private visual(visualRoot: StateBuilder.To<PSO.Molecule.Structure>) {
+        visualRoot.apply(StateTransforms.Model.StructureComplexElement, { type: 'atomic-sequence' }, { ref: 'seq' })
+            .apply(StateTransforms.Representation.StructureRepresentation3D,
+                StructureRepresentation3DHelpers.getDefaultParamsStatic(this.plugin, 'cartoon'), { ref: 'seq-visual' });
+        visualRoot.apply(StateTransforms.Model.StructureComplexElement, { type: 'atomic-het' })
+            .apply(StateTransforms.Representation.StructureRepresentation3D,
+                StructureRepresentation3DHelpers.getDefaultParamsStatic(this.plugin, 'ball-and-stick'), { ref: 'het-visual' });
+        visualRoot.apply(StateTransforms.Model.StructureComplexElement, { type: 'water' })
+            .apply(StateTransforms.Representation.StructureRepresentation3D,
+                StructureRepresentation3DHelpers.getDefaultParamsStatic(this.plugin, 'ball-and-stick', { alpha: 0.51 }), { ref: 'water-visual' });
+        visualRoot.apply(StateTransforms.Model.StructureComplexElement, { type: 'spheres' })
+            .apply(StateTransforms.Representation.StructureRepresentation3D,
+                StructureRepresentation3DHelpers.getDefaultParamsStatic(this.plugin, 'spacefill'), { ref: 'ihm-visual' });
+        return visualRoot;
+    }
+
+    private loadedParams: LoadParams = { url: '', format: 'cif', assemblyId: '' };
+    async load({ url, format = 'cif', assemblyId = '' }: LoadParams) {
+        let loadType: 'full' | 'update' = 'full';
+
+        const state = this.plugin.state.dataState;
+
+        if (this.loadedParams.url !== url || this.loadedParams.format !== format) {
+            loadType = 'full';
+        } else if (this.loadedParams.url === url) {
+            if (state.select('asm').length > 0) loadType = 'update';
+        }
+
+        let tree: StateBuilder.Root;
+        if (loadType === 'full') {
+            await PluginCommands.State.RemoveObject.dispatch(this.plugin, { state, ref: state.tree.root.ref });
+            tree = state.build();
+            this.visual(this.parse(this.download(tree.toRoot(), url), format, assemblyId));
+        } else {
+            tree = state.build();
+            tree.to('asm').update(StateTransforms.Model.StructureAssemblyFromModel, p => ({ ...p, id: assemblyId || 'deposited' }));
+        }
+
+        await PluginCommands.State.Update.dispatch(this.plugin, { state: this.plugin.state.dataState, tree });
+        this.loadedParams = { url, format, assemblyId };
+        PluginCommands.Camera.Reset.dispatch(this.plugin, { });
+    }
+
+    setBackground(color: number) {
+        const renderer = this.plugin.canvas3d.props.renderer;
+        PluginCommands.Canvas3D.SetSettings.dispatch(this.plugin, { settings: { renderer: { ...renderer,  backgroundColor: Color(color) } } });
+    }
+
+    toggleSpin() {
+        const trackball = this.plugin.canvas3d.props.trackball;
+        const spinning = trackball.spin;
+        PluginCommands.Canvas3D.SetSettings.dispatch(this.plugin, { settings: { trackball: { ...trackball, spin: !trackball.spin } } });
+        if (!spinning) PluginCommands.Camera.Reset.dispatch(this.plugin, { });
+    }
+
+    animate = {
+        modelIndex: {
+            maxFPS: 8,
+            onceForward: () => { this.plugin.state.animation.play(AnimateModelIndex, { maxFPS: Math.max(0.5, this.animate.modelIndex.maxFPS | 0), mode: { name: 'once', params: { direction: 'forward' } } }) },
+            onceBackward: () => { this.plugin.state.animation.play(AnimateModelIndex, { maxFPS: Math.max(0.5, this.animate.modelIndex.maxFPS | 0), mode: { name: 'once', params: { direction: 'backward' } } }) },
+            palindrome: () => { this.plugin.state.animation.play(AnimateModelIndex, { maxFPS: Math.max(0.5, this.animate.modelIndex.maxFPS | 0), mode: { name: 'palindrome', params: {} } }) },
+            loop: () => { this.plugin.state.animation.play(AnimateModelIndex, { maxFPS: Math.max(0.5, this.animate.modelIndex.maxFPS | 0), mode: { name: 'loop', params: {} } }) },
+            stop: () => this.plugin.state.animation.stop()
+        }
+    }
+
+    coloring = {
+        applyStripes: async () => {
+            const state = this.plugin.state.dataState;
+
+            const visuals = state.selectQ(q => q.ofTransformer(StateTransforms.Representation.StructureRepresentation3D));
+            const tree = state.build();
+            const colorTheme = { name: StripedResidues.Descriptor.name, params: this.plugin.structureRepresentation.themeCtx.colorThemeRegistry.get(StripedResidues.Descriptor.name).defaultValues };
+
+            for (const v of visuals) {
+                tree.to(v).update(old => ({ ...old, colorTheme }));
+            }
+
+            await PluginCommands.State.Update.dispatch(this.plugin, { state, tree });
+        }
+    }
+
+    interactivity = {
+        highlightOn: () => {
+            const seq_id = 7;
+            const data = (this.plugin.state.dataState.select('asm')[0].obj as PluginStateObject.Molecule.Structure).data;
+            const sel = Script.getStructureSelection(Q => Q.struct.generator.atomGroups({
+                'residue-test': Q.core.rel.eq([Q.struct.atomProperty.macromolecular.label_seq_id(), seq_id]),
+                'group-by': Q.struct.atomProperty.macromolecular.residueKey()
+            }), data);
+            const loci = StructureSelection.toLociWithSourceUnits(sel);
+            this.plugin.interactivity.lociHighlights.highlightOnly({ loci });
+        },
+        clearHighlight: () => {
+            this.plugin.interactivity.lociHighlights.highlightOnly({ loci: EmptyLoci });
+        }
+    }
+
+    tests = {
+        staticSuperposition: async () => {
+            const state = this.plugin.state.dataState;
+            const tree = buildStaticSuperposition(this.plugin, StaticSuperpositionTestData);
+            await PluginCommands.State.RemoveObject.dispatch(this.plugin, { state, ref: StateTransform.RootRef });
+            await PluginCommands.State.Update.dispatch(this.plugin, { state, tree });
+        },
+        dynamicSuperposition: async () => {
+            await PluginCommands.State.RemoveObject.dispatch(this.plugin, { state: this.plugin.state.dataState, ref: StateTransform.RootRef });
+            await dynamicSuperpositionTest(this.plugin, ['1tqn', '2hhb', '4hhb'], 'HEM');
+        },
+        toggleValidationTooltip: async () => {
+            const state = this.plugin.state.behaviorState;
+            const tree = state.build().to(PDBeStructureQualityReport.id).update(PDBeStructureQualityReport, p => ({ ...p, showTooltip: !p.showTooltip }));
+            await PluginCommands.State.Update.dispatch(this.plugin, { state, tree });
+        },
+        showToasts: () => {
+            PluginCommands.Toast.Show.dispatch(this.plugin, {
+                title: 'Toast 1',
+                message: 'This is an example text, timeout 3s',
+                key: 'toast-1',
+                timeoutMs: 3000
+            });
+            PluginCommands.Toast.Show.dispatch(this.plugin, {
+                title: 'Toast 2',
+                message: CustomToastMessage,
+                key: 'toast-2'
+            });
+        },
+        hideToasts: () => {
+            PluginCommands.Toast.Hide.dispatch(this.plugin, { key: 'toast-1' });
+            PluginCommands.Toast.Hide.dispatch(this.plugin, { key: 'toast-2' });
+        }
+    }
+}
+
+(window as any).BasicMolStarWrapper = new BasicWrapper();

src/apps/basic-wrapper/superposition.ts

@@ -0,0 +1,108 @@
+/**
+ * Copyright (c) 2019 mol* contributors, licensed under MIT, See LICENSE file for more info.
+ *
+ * @author David Sehnal <david.sehnal@gmail.com>
+ */
+
+// TODO: move to an "example"
+
+import { PluginContext } from '../../mol-plugin/context';
+import { Mat4 } from '../../mol-math/linear-algebra';
+import { StateHelper } from './helpers';
+import { PluginCommands } from '../../mol-plugin/command';
+import { StateSelection, StateBuilder } from '../../mol-state';
+import { PluginStateObject as PSO } from '../../mol-plugin/state/objects';
+import { MolScriptBuilder as MS } from '../../mol-script/language/builder';
+import { compile } from '../../mol-script/runtime/query/compiler';
+import { StructureSelection, QueryContext } from '../../mol-model/structure';
+import { superposeStructures } from '../../mol-model/structure/structure/util/superposition';
+import Expression from '../../mol-script/language/expression';
+
+export type SuperpositionTestInput = {
+    pdbId: string,
+    auth_asym_id: string,
+    matrix: Mat4
+}[];
+
+// function getAxisAngleTranslation(m: Mat4) {
+//     const translation = Mat4.getTranslation(Vec3.zero(), m);
+//     const axis = Vec3.zero();
+//     const angle = 180 / Math.PI * Quat.getAxisAngle(axis, Mat4.getRotation(Quat.zero(), m));
+//     return { translation, axis, angle };
+// }
+
+export function buildStaticSuperposition(ctx: PluginContext, src: SuperpositionTestInput) {
+    const b = ctx.state.dataState.build().toRoot();
+    for (const s of src) {
+        StateHelper.visual(ctx,
+            StateHelper.transform(
+                StateHelper.selectChain(
+                    StateHelper.structure(
+                        StateHelper.getModel(StateHelper.download(b, `https://www.ebi.ac.uk/pdbe/static/entry/${s.pdbId}_updated.cif`), 'cif')),
+                    s.auth_asym_id
+                ),
+                s.matrix
+            )
+        );
+    }
+    return b;
+}
+
+export const StaticSuperpositionTestData: SuperpositionTestInput = [
+    { pdbId: '1aj5', auth_asym_id: 'A', matrix: Mat4.identity() },
+    { pdbId: '1df0', auth_asym_id: 'B', matrix: Mat4.ofRows(
+        [[0.406, 0.879, 0.248, -200.633],
+         [0.693, -0.473, 0.544, 73.403],
+         [0.596, -0.049, -0.802, -14.209],
+         [0, 0, 0, 1]] )},
+    { pdbId: '1dvi', auth_asym_id: 'A', matrix: Mat4.ofRows(
+        [[-0.053, -0.077, 0.996, -45.633],
+         [-0.312, 0.949, 0.057, -12.255],
+         [-0.949, -0.307, -0.074, 53.562],
+         [0, 0, 0, 1]] )}
+];
+
+export async function dynamicSuperpositionTest(ctx: PluginContext, src: string[], comp_id: string) {
+    const state = ctx.state.dataState;
+
+    const structures = state.build().toRoot();
+    for (const s of src) {
+        StateHelper.structure(
+            StateHelper.getModel(StateHelper.download(structures, `https://www.ebi.ac.uk/pdbe/static/entry/${s}_updated.cif`), 'cif'));
+    }
+
+    await PluginCommands.State.Update.dispatch(ctx, { state, tree: structures });
+
+    const pivot = MS.struct.filter.first([
+        MS.struct.generator.atomGroups({
+            'residue-test': MS.core.rel.eq([MS.struct.atomProperty.macromolecular.label_comp_id(), comp_id]),
+            'group-by': MS.struct.atomProperty.macromolecular.residueKey()
+        })
+    ]);
+    const rest = MS.struct.modifier.exceptBy({
+        0: MS.struct.generator.all(),
+        by: pivot
+    });
+
+    const query = compile<StructureSelection>(pivot);
+    const xs = state.select(StateSelection.Generators.rootsOfType(PSO.Molecule.Structure));
+    const selections = xs.map(s => StructureSelection.toLociWithCurrentUnits(query(new QueryContext(s.obj!.data))));
+
+    const transforms = superposeStructures(selections);
+    const visuals = state.build();
+
+    siteVisual(ctx, StateHelper.selectSurroundingsOfFirstResidue(visuals.to(xs[0].transform.ref), 'HEM', 7), pivot, rest);
+    for (let i = 1; i < selections.length; i++) {
+        const root = visuals.to(xs[i].transform.ref);
+        siteVisual(ctx,
+            StateHelper.transform(StateHelper.selectSurroundingsOfFirstResidue(root, 'HEM', 7), transforms[i - 1].bTransform),
+            pivot, rest);
+    }
+
+    await PluginCommands.State.Update.dispatch(ctx, { state, tree: visuals });
+}
+
+function siteVisual(ctx: PluginContext, b: StateBuilder.To<PSO.Molecule.Structure>, pivot: Expression, rest: Expression) {
+    StateHelper.ballsAndSticks(ctx, b, pivot, 'residue-name');
+    StateHelper.ballsAndSticks(ctx, b, rest, 'uniform');
+}

src/apps/chem-comp-bond/create-table.ts

@@ -0,0 +1,252 @@
+/**
+ * Copyright (c) 2018-2019 mol* contributors, licensed under MIT, See LICENSE file for more info.
+ *
+ * @author Alexander Rose <alexander.rose@weirdbyte.de>
+ */
+
+import * as argparse from 'argparse'
+import * as util from 'util'
+import * as path from 'path'
+import * as fs from 'fs'
+import * as zlib from 'zlib'
+import fetch from 'node-fetch'
+require('util.promisify').shim()
+const readFile = util.promisify(fs.readFile)
+const writeFile = util.promisify(fs.writeFile)
+
+import { Progress } from '../../mol-task'
+import { Database, Table, DatabaseCollection } from '../../mol-data/db'
+import { CIF } from '../../mol-io/reader/cif'
+import { CifWriter } from '../../mol-io/writer/cif'
+import { CCD_Schema } from '../../mol-io/reader/cif/schema/ccd'
+import { SetUtils } from '../../mol-util/set'
+import { DefaultMap } from '../../mol-util/map'
+import { mmCIF_chemCompBond_schema } from '../../mol-io/reader/cif/schema/mmcif-extras';
+
+export async function ensureAvailable(path: string, url: string) {
+    if (FORCE_DOWNLOAD || !fs.existsSync(path)) {
+        console.log(`downloading ${url}...`)
+        const data = await fetch(url)
+        if (!fs.existsSync(DATA_DIR)) {
+            fs.mkdirSync(DATA_DIR);
+        }
+        if (url.endsWith('.gz')) {
+            await writeFile(path, zlib.gunzipSync(await data.buffer()))
+        } else {
+            await writeFile(path, await data.text())
+        }
+        console.log(`done downloading ${url}`)
+    }
+}
+
+export async function ensureDataAvailable() {
+    await ensureAvailable(CCD_PATH, CCD_URL)
+    await ensureAvailable(PVCD_PATH, PVCD_URL)
+}
+
+export async function readFileAsCollection<S extends Database.Schema>(path: string, schema: S) {
+    const parsed = await parseCif(await readFile(path, 'utf8'))
+    return CIF.toDatabaseCollection(schema, parsed.result)
+}
+
+export async function readCCD() {
+    return readFileAsCollection(CCD_PATH, CCD_Schema)
+}
+
+export async function readPVCD() {
+    return readFileAsCollection(PVCD_PATH, CCD_Schema)
+}
+
+async function parseCif(data: string | Uint8Array) {
+    const comp = CIF.parse(data);
+    console.time('parse cif');
+    const parsed = await comp.run(p => console.log(Progress.format(p)), 250);
+    console.timeEnd('parse cif');
+    if (parsed.isError) throw parsed;
+    return parsed
+}
+
+export function getEncodedCif(name: string, database: Database<Database.Schema>, binary = false) {
+    const encoder = CifWriter.createEncoder({ binary, encoderName: 'mol*' });
+    CifWriter.Encoder.writeDatabase(encoder, name, database)
+    return encoder.getData();
+}
+
+type CCB = Table<CCD_Schema['chem_comp_bond']>
+type CCA = Table<CCD_Schema['chem_comp_atom']>
+
+function ccbKey(compId: string, atomId1: string, atomId2: string) {
+    return atomId1 < atomId2 ? `${compId}:${atomId1}-${atomId2}` : `${compId}:${atomId2}-${atomId1}`
+}
+
+function addChemCompBondToSet(set: Set<string>, ccb: CCB) {
+    for (let i = 0, il = ccb._rowCount; i < il; ++i) {
+        set.add(ccbKey(ccb.comp_id.value(i), ccb.atom_id_1.value(i), ccb.atom_id_2.value(i)))
+    }
+    return set
+}
+
+function addChemCompAtomToSet(set: Set<string>, cca: CCA) {
+    for (let i = 0, il = cca._rowCount; i < il; ++i) {
+        set.add(cca.atom_id.value(i))
+    }
+    return set
+}
+
+function checkAddingBondsFromPVCD(pvcd: DatabaseCollection<CCD_Schema>) {
+    const ccbSetByParent = DefaultMap<string, Set<string>>(() => new Set())
+
+    for (const k in pvcd) {
+        const { chem_comp, chem_comp_bond } = pvcd[k]
+        if (chem_comp_bond._rowCount) {
+            const parentIds = chem_comp.mon_nstd_parent_comp_id.value(0)
+            if (parentIds.length === 0) {
+                const set = ccbSetByParent.getDefault(chem_comp.id.value(0))
+                addChemCompBondToSet(set, chem_comp_bond)
+            } else {
+                for (let i = 0, il = parentIds.length; i < il; ++i) {
+                    const parentId = parentIds[i]
+                    const set = ccbSetByParent.getDefault(parentId)
+                    addChemCompBondToSet(set, chem_comp_bond)
+                }
+            }
+        }
+    }
+
+    for (const k in pvcd) {
+        const { chem_comp, chem_comp_atom, chem_comp_bond } = pvcd[k]
+        if (chem_comp_bond._rowCount) {
+            const parentIds = chem_comp.mon_nstd_parent_comp_id.value(0)
+            if (parentIds.length > 0) {
+                for (let i = 0, il = parentIds.length; i < il; ++i) {
+                    const entryBonds = addChemCompBondToSet(new Set<string>(), chem_comp_bond)
+                    const entryAtoms = addChemCompAtomToSet(new Set<string>(), chem_comp_atom)
+                    const extraBonds = SetUtils.difference(ccbSetByParent.get(parentIds[i])!, entryBonds)
+                    extraBonds.forEach(bk => {
+                        const [a1, a2] = bk.split('|')
+                        if (entryAtoms.has(a1) && entryAtoms.has(a2)) {
+                            console.error(`Adding all PVCD bonds would wrongly add bond ${bk} for ${k}`)
+                        }
+                    })
+                }
+            }
+        }
+    }
+}
+
+async function createBonds() {
+    await ensureDataAvailable()
+    const ccd = await readCCD()
+    const pvcd = await readPVCD()
+
+    const ccbSet = new Set<string>()
+
+    const comp_id: string[] = []
+    const atom_id_1: string[] = []
+    const atom_id_2: string[] = []
+    const value_order: string[] = []
+    const pdbx_aromatic_flag: string[] = []
+    const pdbx_stereo_config: string[] = []
+    const molstar_protonation_variant: string[] = []
+
+    function addBonds(compId: string, ccb: CCB, protonationVariant: boolean) {
+        for (let i = 0, il = ccb._rowCount; i < il; ++i) {
+            const atomId1 = ccb.atom_id_1.value(i)
+            const atomId2 = ccb.atom_id_2.value(i)
+            const k = ccbKey(compId, atomId1, atomId2)
+            if (!ccbSet.has(k)) {
+                atom_id_1.push(atomId1)
+                atom_id_2.push(atomId2)
+                comp_id.push(compId)
+                value_order.push(ccb.value_order.value(i))
+                pdbx_aromatic_flag.push(ccb.pdbx_aromatic_flag.value(i))
+                pdbx_stereo_config.push(ccb.pdbx_stereo_config.value(i))
+                molstar_protonation_variant.push(protonationVariant ? 'Y' : 'N')
+                ccbSet.add(k)
+            }
+        }
+    }
+
+    // check adding bonds from PVCD
+    checkAddingBondsFromPVCD(pvcd)
+
+    // add bonds from PVCD
+    for (const k in pvcd) {
+        const { chem_comp, chem_comp_bond } = pvcd[k]
+        if (chem_comp_bond._rowCount) {
+            const parentIds = chem_comp.mon_nstd_parent_comp_id.value(0)
+            if (parentIds.length === 0) {
+                addBonds(chem_comp.id.value(0), chem_comp_bond, false)
+            } else {
+                for (let i = 0, il = parentIds.length; i < il; ++i) {
+                    addBonds(parentIds[i], chem_comp_bond, true)
+                }
+            }
+        }
+    }
+
+    // add bonds from CCD
+    for (const k in ccd) {
+        const { chem_comp, chem_comp_bond } = ccd[k]
+        if (chem_comp_bond._rowCount) {
+            addBonds(chem_comp.id.value(0), chem_comp_bond, false)
+        }
+    }
+
+    const bondTable = Table.ofArrays(mmCIF_chemCompBond_schema, {
+        comp_id, atom_id_1, atom_id_2, value_order,
+        pdbx_aromatic_flag, pdbx_stereo_config, molstar_protonation_variant
+    })
+
+    const bondDatabase =  Database.ofTables(
+        TABLE_NAME,
+        { chem_comp_bond: mmCIF_chemCompBond_schema },
+        { chem_comp_bond: bondTable }
+    )
+
+    return bondDatabase
+}
+
+async function run(out: string, binary = false) {
+    const bonds = await createBonds()
+
+    const cif = getEncodedCif(TABLE_NAME, bonds, binary)
+    if (!fs.existsSync(path.dirname(out))) {
+        fs.mkdirSync(path.dirname(out));
+    }
+    writeFile(out, cif)
+}
+
+const TABLE_NAME = 'CHEM_COMP_BONDS'
+
+const DATA_DIR = path.join(__dirname, '..', '..', '..', 'build/data')
+const CCD_PATH = path.join(DATA_DIR, 'components.cif')
+const PVCD_PATH = path.join(DATA_DIR, 'aa-variants-v1.cif')
+const CCD_URL = 'http://ftp.wwpdb.org/pub/pdb/data/monomers/components.cif'
+const PVCD_URL = 'http://ftp.wwpdb.org/pub/pdb/data/monomers/aa-variants-v1.cif'
+
+const parser = new argparse.ArgumentParser({
+  addHelp: true,
+  description: 'Create a cif file with one big table of all chem_comp_bond entries from the CCD and PVCD.'
+});
+parser.addArgument('out', {
+    help: 'Generated file output path.'
+});
+parser.addArgument([ '--forceDownload', '-f' ], {
+    action: 'storeTrue',
+    help: 'Force download of CCD and PVCD.'
+});
+parser.addArgument([ '--binary', '-b' ], {
+    action: 'storeTrue',
+    help: 'Output as BinaryCIF.'
+});
+interface Args {
+    out: string
+    forceDownload?: boolean
+    binary?: boolean
+}
+const args: Args = parser.parseArgs();
+
+const FORCE_DOWNLOAD = args.forceDownload
+
+run(args.out, args.binary)

src/apps/demos/lighting/index.html

@@ -12,18 +12,18 @@
             }
             #app {
                 position: absolute;
-                width: 100%;
-                height: 100%;
+                left: 160px;
+                top: 100px;
+                width: 600px;
+                height: 600px;
+                border: 1px solid #ccc;
             }
 
             #controls {
                 position: absolute;
                 width: 150px;
-                bottom: 100px;
-                right: 50px;
-                z-index: 10;
-                font-family: sans-serif;
-                font-size: smaller;
+                top: 100px;
+                left: 780px;
             }
 
             #controls > button {
@@ -38,22 +38,21 @@
                 display: block;
             }
         </style>
-        <link rel="stylesheet" type="text/css" href="molstar.css" />
+        <link rel="stylesheet" type="text/css" href="app.css" />
         <script type="text/javascript" src="./index.js"></script>
     </head>
     <body>
         <div id='controls'></div>
         <div id="app"></div>
-        <script>
-            LightingDemo.init('app').then(() => {
-                LightingDemo.load({ url: 'https://models.rcsb.org/4KTC.bcif', assemblyId: '1' }, 5, 1.3);
-            });
-
+        <script>      
+            LightingDemo.init('app')
+            LightingDemo.load({ url: 'https://files.rcsb.org/download/1M07.cif', assemblyId: '1' })
+            
             addHeader('Example PDB IDs');
-            addControl('4KTC', () => LightingDemo.load({ url: 'https://models.rcsb.org/4KTC.bcif', assemblyId: '1' }, 5, 1.3));
-            addControl('5FJ5', () => LightingDemo.load({ url: 'https://models.rcsb.org/5FJ5.bcif', assemblyId: '1' }, 8, 1.8));
-            addControl('1UPN', () => LightingDemo.load({ url: 'https://models.rcsb.org/1UPN.bcif', assemblyId: '1' }, 7, 1.6));
-            addControl('1RB8', () => LightingDemo.load({ url: 'https://models.rcsb.org/1RB8.bcif', assemblyId: '1' }, 6, 1.3));
+            addControl('1M07', () => LightingDemo.load({ url: 'https://files.rcsb.org/download/1M07.cif', assemblyId: '1' }));
+            addControl('6HY0', () => LightingDemo.load({ url: 'https://files.rcsb.org/download/6HY0.cif', assemblyId: '1' }));
+            addControl('6QVK', () => LightingDemo.load({ url: 'https://files.rcsb.org/download/6QVK.cif', assemblyId: '1' }));
+            addControl('1RB8', () => LightingDemo.load({ url: 'https://files.rcsb.org/download/1RB8.cif', assemblyId: '1' }));
 
             addSeparator()
 
@@ -84,6 +83,5 @@
                 $('controls').appendChild(h);
             }
         </script>
-        <!-- __MOLSTAR_ANALYTICS__ -->
     </body>
 </html>

src/apps/demos/lighting/index.ts

@@ -0,0 +1,166 @@
+/**
+ * Copyright (c) 2019 mol* contributors, licensed under MIT, See LICENSE file for more info.
+ *
+ * @author Alexander Rose <alexander.rose@weirdbyte.de>
+ */
+
+import { createPlugin, DefaultPluginSpec } from '../../../mol-plugin';
+import './index.html'
+import { PluginContext } from '../../../mol-plugin/context';
+import { PluginCommands } from '../../../mol-plugin/command';
+import { StateTransforms } from '../../../mol-plugin/state/transforms';
+import { StructureRepresentation3DHelpers } from '../../../mol-plugin/state/transforms/representation';
+import { PluginStateObject as PSO } from '../../../mol-plugin/state/objects';
+import { StateBuilder } from '../../../mol-state';
+import { Canvas3DProps } from '../../../mol-canvas3d/canvas3d';
+require('mol-plugin/skin/light.scss')
+
+type SupportedFormats = 'cif' | 'pdb'
+type LoadParams = { url: string, format?: SupportedFormats, assemblyId?: string }
+
+const Canvas3DPresets = {
+    illustrative: {
+        multiSample: {
+            mode: 'temporal' as Canvas3DProps['multiSample']['mode']
+        },
+        postprocessing: {
+            occlusionEnable: true,
+            occlusionBias: 0.8,
+            occlusionKernelSize: 6,
+            outlineEnable: true,
+        },
+        renderer: {
+            ambientIntensity: 1,
+            lightIntensity: 0,
+        }
+    },
+    occlusion: {
+        multiSample: {
+            mode: 'temporal' as Canvas3DProps['multiSample']['mode']
+        },
+        postprocessing: {
+            occlusionEnable: true,
+            occlusionBias: 0.8,
+            occlusionKernelSize: 6,
+            outlineEnable: false,
+        },
+        renderer: {
+            ambientIntensity: 0.4,
+            lightIntensity: 0.6,
+        }
+    },
+    standard: {
+        multiSample: {
+            mode: 'off' as Canvas3DProps['multiSample']['mode']
+        },
+        postprocessing: {
+            occlusionEnable: false,
+            outlineEnable: false,
+        },
+        renderer: {
+            ambientIntensity: 0.4,
+            lightIntensity: 0.6,
+        }
+    }
+}
+
+type Canvas3DPreset = keyof typeof Canvas3DPresets
+
+function getPreset(preset: Canvas3DPreset) {
+    switch (preset) {
+        case 'illustrative': return Canvas3DPresets['illustrative']
+        case 'standard': return Canvas3DPresets['standard']
+        case 'occlusion': return Canvas3DPresets['occlusion']
+    }
+}
+
+class LightingDemo {
+    plugin: PluginContext;
+
+    init(target: string | HTMLElement) {
+        this.plugin = createPlugin(typeof target === 'string' ? document.getElementById(target)! : target, {
+            ...DefaultPluginSpec,
+            layout: {
+                initial: {
+                    isExpanded: false,
+                    showControls: false
+                },
+                controls: { left: 'none', right: 'none', top: 'none', bottom: 'none' }
+            }
+        });
+
+        this.setPreset('illustrative');
+    }
+
+    setPreset(preset: Canvas3DPreset) {
+        const props = getPreset(preset)
+        PluginCommands.Canvas3D.SetSettings.dispatch(this.plugin, { settings: {
+            ...props,
+            multiSample: {
+                ...this.plugin.canvas3d.props.multiSample,
+                ...props.multiSample
+            },
+            renderer: {
+                ...this.plugin.canvas3d.props.renderer,
+                ...props.renderer
+            },
+            postprocessing: {
+                ...this.plugin.canvas3d.props.postprocessing,
+                ...props.postprocessing
+            },
+        }});
+    }
+
+    private download(b: StateBuilder.To<PSO.Root>, url: string) {
+        return b.apply(StateTransforms.Data.Download, { url, isBinary: false })
+    }
+
+    private parse(b: StateBuilder.To<PSO.Data.Binary | PSO.Data.String>, format: SupportedFormats, assemblyId: string) {
+        const parsed = format === 'cif'
+            ? b.apply(StateTransforms.Data.ParseCif).apply(StateTransforms.Model.TrajectoryFromMmCif)
+            : b.apply(StateTransforms.Model.TrajectoryFromPDB);
+
+        return parsed
+            .apply(StateTransforms.Model.ModelFromTrajectory, { modelIndex: 0 })
+            .apply(StateTransforms.Model.StructureAssemblyFromModel, { id: assemblyId || 'deposited' }, { ref: 'asm' });
+    }
+
+    private visual(visualRoot: StateBuilder.To<PSO.Molecule.Structure>) {
+        visualRoot.apply(StateTransforms.Model.StructureComplexElement, { type: 'atomic-sequence' })
+            .apply(StateTransforms.Representation.StructureRepresentation3D,
+                StructureRepresentation3DHelpers.getDefaultParamsStatic(this.plugin, 'spacefill', {}, 'illustrative'), { ref: 'seq-visual' });
+        visualRoot.apply(StateTransforms.Model.StructureComplexElement, { type: 'atomic-het' })
+            .apply(StateTransforms.Representation.StructureRepresentation3D,
+                StructureRepresentation3DHelpers.getDefaultParamsStatic(this.plugin, 'ball-and-stick'), { ref: 'het-visual' });
+        return visualRoot;
+    }
+
+    private loadedParams: LoadParams = { url: '', format: 'cif', assemblyId: '' };
+    async load({ url, format = 'cif', assemblyId = '' }: LoadParams) {
+        let loadType: 'full' | 'update' = 'full';
+
+        const state = this.plugin.state.dataState;
+
+        if (this.loadedParams.url !== url || this.loadedParams.format !== format) {
+            loadType = 'full';
+        } else if (this.loadedParams.url === url) {
+            if (state.select('asm').length > 0) loadType = 'update';
+        }
+
+        let tree: StateBuilder.Root;
+        if (loadType === 'full') {
+            await PluginCommands.State.RemoveObject.dispatch(this.plugin, { state, ref: state.tree.root.ref });
+            tree = state.build();
+            this.visual(this.parse(this.download(tree.toRoot(), url), format, assemblyId));
+        } else {
+            tree = state.build();
+            tree.to('asm').update(StateTransforms.Model.StructureAssemblyFromModel, p => ({ ...p, id: assemblyId || 'deposited' }));
+        }
+
+        await PluginCommands.State.Update.dispatch(this.plugin, { state: this.plugin.state.dataState, tree });
+        this.loadedParams = { url, format, assemblyId };
+        PluginCommands.Camera.Reset.dispatch(this.plugin, { });
+    }
+}
+
+(window as any).LightingDemo = new LightingDemo();

src/apps/docking-viewer/index.html

@@ -1,37 +0,0 @@
-<!DOCTYPE html>
-<html lang="en">
-    <head>
-        <meta charset="utf-8" />
-        <meta name="viewport" content="width=device-width, user-scalable=no, minimum-scale=1.0, maximum-scale=1.0">
-        <title>Mol* Docking Viewer</title>
-        <style>
-            #app {
-                position: absolute;
-                left: 100px;
-                top: 100px;
-                width: 800px;
-                height: 600px;
-            }
-        </style>
-        <link rel="stylesheet" type="text/css" href="molstar.css" />
-    </head>
-    <body>
-        <div id="app"></div>
-        <script type="text/javascript" src="./molstar.js"></script>
-        <script type="text/javascript">
-            function getParam(name, regex) {
-                var r = new RegExp(name + '=' + '(' + regex + ')[&]?', 'i');
-                return decodeURIComponent(((window.location.search || '').match(r) || [])[1] || '');
-            }
-            var pdbqt = getParam('pdbqt', '[^&]+').trim() || '../../examples/ace2.pdbqt';
-            var mol2 = getParam('mol2', '[^&]+').trim() || '../../examples/ace2-hit.mol2';
-
-            DockingViewer.create('app', [0x33DD22, 0x1133EE], true).then(viewer => {
-                viewer.loadStructuresFromUrlsAndMerge([
-                    { url: pdbqt, format: 'pdbqt' },
-                    { url: mol2, format: 'mol2' }
-                ]);
-            });
-        </script>
-    </body>
-</html>

src/apps/docking-viewer/index.ts

@@ -1,216 +0,0 @@
-/**
- * Copyright (c) 2018-2020 mol* contributors, licensed under MIT, See LICENSE file for more info.
- *
- * @author David Sehnal <david.sehnal@gmail.com>
- * @author Alexander Rose <alexander.rose@weirdbyte.de>
- */
-
-import { Structure } from '../../mol-model/structure';
-import { BuiltInTrajectoryFormat } from '../../mol-plugin-state/formats/trajectory';
-import { PluginStateObject as PSO, PluginStateTransform } from '../../mol-plugin-state/objects';
-import { createPluginUI } from '../../mol-plugin-ui/react18';
-import { PluginUIContext } from '../../mol-plugin-ui/context';
-import { PluginLayoutControlsDisplay } from '../../mol-plugin/layout';
-import { DefaultPluginUISpec, PluginUISpec } from '../../mol-plugin-ui/spec';
-import { PluginBehaviors } from '../../mol-plugin/behavior';
-import { PluginCommands } from '../../mol-plugin/commands';
-import { PluginConfig } from '../../mol-plugin/config';
-import { PluginSpec } from '../../mol-plugin/spec';
-import { StateObject } from '../../mol-state';
-import { Task } from '../../mol-task';
-import { Color } from '../../mol-util/color';
-import { ColorNames } from '../../mol-util/color/names';
-import { ParamDefinition as PD } from '../../mol-util/param-definition';
-import '../../mol-util/polyfill';
-import { ObjectKeys } from '../../mol-util/type-helpers';
-import './index.html';
-import { ShowButtons, StructurePreset, ViewportComponent } from './viewport';
-
-require('mol-plugin-ui/skin/light.scss');
-
-export { PLUGIN_VERSION as version } from '../../mol-plugin/version';
-export { setDebugMode, setProductionMode } from '../../mol-util/debug';
-export { Viewer as DockingViewer };
-
-const DefaultViewerOptions = {
-    extensions: ObjectKeys({}),
-    layoutIsExpanded: true,
-    layoutShowControls: true,
-    layoutShowRemoteState: true,
-    layoutControlsDisplay: 'reactive' as PluginLayoutControlsDisplay,
-    layoutShowSequence: true,
-    layoutShowLog: true,
-    layoutShowLeftPanel: true,
-
-    viewportShowExpand: PluginConfig.Viewport.ShowExpand.defaultValue,
-    viewportShowControls: PluginConfig.Viewport.ShowControls.defaultValue,
-    viewportShowSettings: PluginConfig.Viewport.ShowSettings.defaultValue,
-    viewportShowSelectionMode: PluginConfig.Viewport.ShowSelectionMode.defaultValue,
-    viewportShowAnimation: PluginConfig.Viewport.ShowAnimation.defaultValue,
-    pluginStateServer: PluginConfig.State.DefaultServer.defaultValue,
-    volumeStreamingServer: PluginConfig.VolumeStreaming.DefaultServer.defaultValue,
-    pdbProvider: PluginConfig.Download.DefaultPdbProvider.defaultValue,
-    emdbProvider: PluginConfig.Download.DefaultEmdbProvider.defaultValue,
-};
-
-class Viewer {
-    constructor(public plugin: PluginUIContext) {
-    }
-
-    static async create(elementOrId: string | HTMLElement, colors = [Color(0x992211), Color(0xDDDDDD)], showButtons = true) {
-        const o = {
-            ...DefaultViewerOptions, ...{
-                layoutIsExpanded: false,
-                layoutShowControls: false,
-                layoutShowRemoteState: false,
-                layoutShowSequence: true,
-                layoutShowLog: false,
-                layoutShowLeftPanel: true,
-
-                viewportShowExpand: true,
-                viewportShowControls: false,
-                viewportShowSettings: false,
-                viewportShowSelectionMode: false,
-                viewportShowAnimation: false,
-            }
-        };
-        const defaultSpec = DefaultPluginUISpec();
-
-        const spec: PluginUISpec = {
-            actions: defaultSpec.actions,
-            behaviors: [
-                PluginSpec.Behavior(PluginBehaviors.Representation.HighlightLoci, { mark: false }),
-                PluginSpec.Behavior(PluginBehaviors.Representation.DefaultLociLabelProvider),
-                PluginSpec.Behavior(PluginBehaviors.Camera.FocusLoci),
-
-                PluginSpec.Behavior(PluginBehaviors.CustomProps.StructureInfo),
-                PluginSpec.Behavior(PluginBehaviors.CustomProps.Interactions),
-                PluginSpec.Behavior(PluginBehaviors.CustomProps.SecondaryStructure),
-            ],
-            animations: defaultSpec.animations,
-            customParamEditors: defaultSpec.customParamEditors,
-            layout: {
-                initial: {
-                    isExpanded: o.layoutIsExpanded,
-                    showControls: o.layoutShowControls,
-                    controlsDisplay: o.layoutControlsDisplay,
-                },
-            },
-            components: {
-                ...defaultSpec.components,
-                controls: {
-                    ...defaultSpec.components?.controls,
-                    top: o.layoutShowSequence ? undefined : 'none',
-                    bottom: o.layoutShowLog ? undefined : 'none',
-                    left: o.layoutShowLeftPanel ? undefined : 'none',
-                },
-                remoteState: o.layoutShowRemoteState ? 'default' : 'none',
-                viewport: {
-                    view: ViewportComponent
-                }
-            },
-            config: [
-                [PluginConfig.Viewport.ShowExpand, o.viewportShowExpand],
-                [PluginConfig.Viewport.ShowControls, o.viewportShowControls],
-                [PluginConfig.Viewport.ShowSettings, o.viewportShowSettings],
-                [PluginConfig.Viewport.ShowSelectionMode, o.viewportShowSelectionMode],
-                [PluginConfig.Viewport.ShowAnimation, o.viewportShowAnimation],
-                [PluginConfig.State.DefaultServer, o.pluginStateServer],
-                [PluginConfig.State.CurrentServer, o.pluginStateServer],
-                [PluginConfig.VolumeStreaming.DefaultServer, o.volumeStreamingServer],
-                [PluginConfig.Download.DefaultPdbProvider, o.pdbProvider],
-                [PluginConfig.Download.DefaultEmdbProvider, o.emdbProvider],
-                [ShowButtons, showButtons]
-            ]
-        };
-
-        const element = typeof elementOrId === 'string'
-            ? document.getElementById(elementOrId)
-            : elementOrId;
-        if (!element) throw new Error(`Could not get element with id '${elementOrId}'`);
-        const plugin = await createPluginUI(element, spec);
-
-        (plugin.customState as any) = {
-            colorPalette: {
-                name: 'colors',
-                params: { list: { colors } }
-            }
-        };
-
-        PluginCommands.Canvas3D.SetSettings(plugin, {
-            settings: {
-                renderer: {
-                    ...plugin.canvas3d!.props.renderer,
-                    backgroundColor: ColorNames.white,
-                },
-                camera: {
-                    ...plugin.canvas3d!.props.camera,
-                    helper: { axes: { name: 'off', params: {} } }
-                }
-            }
-        });
-
-        return new Viewer(plugin);
-    }
-
-    async loadStructuresFromUrlsAndMerge(sources: { url: string, format: BuiltInTrajectoryFormat, isBinary?: boolean }[]) {
-        const structures: { ref: string }[] = [];
-        for (const { url, format, isBinary } of sources) {
-            const data = await this.plugin.builders.data.download({ url, isBinary });
-            const trajectory = await this.plugin.builders.structure.parseTrajectory(data, format);
-            const model = await this.plugin.builders.structure.createModel(trajectory);
-            const modelProperties = await this.plugin.builders.structure.insertModelProperties(model);
-            const structure = await this.plugin.builders.structure.createStructure(modelProperties || model);
-            const structureProperties = await this.plugin.builders.structure.insertStructureProperties(structure);
-
-            structures.push({ ref: structureProperties?.ref || structure.ref });
-        }
-
-        // remove current structures from hierarchy as they will be merged
-        // TODO only works with using loadStructuresFromUrlsAndMerge once
-        //      need some more API metho to work with the hierarchy
-        this.plugin.managers.structure.hierarchy.updateCurrent(this.plugin.managers.structure.hierarchy.current.structures, 'remove');
-
-        const dependsOn = structures.map(({ ref }) => ref);
-        const data = this.plugin.state.data.build().toRoot().apply(MergeStructures, { structures }, { dependsOn });
-        const structure = await data.commit();
-        const structureProperties = await this.plugin.builders.structure.insertStructureProperties(structure);
-        this.plugin.behaviors.canvas3d.initialized.subscribe(async v => {
-            await this.plugin.builders.structure.representation.applyPreset(structureProperties || structure, StructurePreset);
-        });
-    }
-}
-
-type MergeStructures = typeof MergeStructures
-const MergeStructures = PluginStateTransform.BuiltIn({
-    name: 'merge-structures',
-    display: { name: 'Merge Structures', description: 'Merge Structure' },
-    from: PSO.Root,
-    to: PSO.Molecule.Structure,
-    params: {
-        structures: PD.ObjectList({
-            ref: PD.Text('')
-        }, ({ ref }) => ref, { isHidden: true })
-    }
-})({
-    apply({ params, dependencies }) {
-        return Task.create('Merge Structures', async ctx => {
-            if (params.structures.length === 0) return StateObject.Null;
-
-            const first = dependencies![params.structures[0].ref].data as Structure;
-            const builder = Structure.Builder({ masterModel: first.models[0] });
-            for (const { ref } of params.structures) {
-                const s = dependencies![ref].data as Structure;
-                for (const unit of s.units) {
-                    // TODO invariantId
-                    builder.addUnit(unit.kind, unit.model, unit.conformation.operator, unit.elements, unit.traits);
-                }
-            }
-
-            const structure = builder.getStructure();
-            return new PSO.Molecule.Structure(structure, { label: 'Merged Structure' });
-        });
-    }
-});
-
-(window as any).DockingViewer = Viewer;

src/apps/docking-viewer/viewport.tsx

@@ -1,276 +0,0 @@
-/**
- * Copyright (c) 2020-2022 mol* contributors, licensed under MIT, See LICENSE file for more info.
- *
- * @author Alexander Rose <alexander.rose@weirdbyte.de>
- */
-
-import { InteractionsRepresentationProvider } from '../../mol-model-props/computed/representations/interactions';
-import { InteractionTypeColorThemeProvider } from '../../mol-model-props/computed/themes/interaction-type';
-import { presetStaticComponent, StructureRepresentationPresetProvider } from '../../mol-plugin-state/builder/structure/representation-preset';
-import { StructureSelectionQueries, StructureSelectionQuery } from '../../mol-plugin-state/helpers/structure-selection-query';
-import { StructureRef } from '../../mol-plugin-state/manager/structure/hierarchy-state';
-import { PluginUIComponent } from '../../mol-plugin-ui/base';
-import { LociLabels } from '../../mol-plugin-ui/controls';
-import { Button } from '../../mol-plugin-ui/controls/common';
-import { BackgroundTaskProgress } from '../../mol-plugin-ui/task';
-import { Toasts } from '../../mol-plugin-ui/toast';
-import { Viewport, ViewportControls } from '../../mol-plugin-ui/viewport';
-import { PluginCommands } from '../../mol-plugin/commands';
-import { PluginConfig } from '../../mol-plugin/config';
-import { PluginContext } from '../../mol-plugin/context';
-import { MolScriptBuilder as MS } from '../../mol-script/language/builder';
-import { StateObjectRef } from '../../mol-state';
-import { Color } from '../../mol-util/color';
-import { Material } from '../../mol-util/material';
-
-function shinyStyle(plugin: PluginContext) {
-    return PluginCommands.Canvas3D.SetSettings(plugin, { settings: {
-        renderer: {
-            ...plugin.canvas3d!.props.renderer,
-        },
-        postprocessing: {
-            ...plugin.canvas3d!.props.postprocessing,
-            occlusion: { name: 'off', params: {} },
-            outline: { name: 'off', params: {} }
-        }
-    } });
-}
-
-function occlusionStyle(plugin: PluginContext) {
-    return PluginCommands.Canvas3D.SetSettings(plugin, { settings: {
-        renderer: {
-            ...plugin.canvas3d!.props.renderer,
-        },
-        postprocessing: {
-            ...plugin.canvas3d!.props.postprocessing,
-            occlusion: { name: 'on', params: {
-                bias: 0.8,
-                blurKernelSize: 15,
-                radius: 5,
-                samples: 32,
-                resolutionScale: 1
-            } },
-            outline: { name: 'on', params: {
-                scale: 1.0,
-                threshold: 0.33,
-                color: Color(0x0000),
-            } }
-        }
-    } });
-}
-
-const ligandPlusSurroundings = StructureSelectionQuery('Surrounding Residues (5 \u212B) of Ligand plus Ligand itself', MS.struct.modifier.union([
-    MS.struct.modifier.includeSurroundings({
-        0: StructureSelectionQueries.ligand.expression,
-        radius: 5,
-        'as-whole-residues': true
-    })
-]));
-
-const ligandSurroundings = StructureSelectionQuery('Surrounding Residues (5 \u212B) of Ligand', MS.struct.modifier.union([
-    MS.struct.modifier.exceptBy({
-        0: ligandPlusSurroundings.expression,
-        by: StructureSelectionQueries.ligand.expression
-    })
-]));
-
-const PresetParams = {
-    ...StructureRepresentationPresetProvider.CommonParams,
-};
-
-const CustomMaterial = Material({ roughness: 0.2, metalness: 0 });
-
-export const StructurePreset = StructureRepresentationPresetProvider({
-    id: 'preset-structure',
-    display: { name: 'Structure' },
-    params: () => PresetParams,
-    async apply(ref, params, plugin) {
-        const structureCell = StateObjectRef.resolveAndCheck(plugin.state.data, ref);
-        if (!structureCell) return {};
-
-        const components = {
-            ligand: await presetStaticComponent(plugin, structureCell, 'ligand'),
-            polymer: await presetStaticComponent(plugin, structureCell, 'polymer'),
-        };
-
-        const { update, builder, typeParams } = StructureRepresentationPresetProvider.reprBuilder(plugin, params);
-        const representations = {
-            ligand: builder.buildRepresentation(update, components.ligand, { type: 'ball-and-stick', typeParams: { ...typeParams, material: CustomMaterial, sizeFactor: 0.35 }, color: 'element-symbol', colorParams: { carbonColor: { name: 'element-symbol', params: {} } } }, { tag: 'ligand' }),
-            polymer: builder.buildRepresentation(update, components.polymer, { type: 'cartoon', typeParams: { ...typeParams, material: CustomMaterial }, color: 'chain-id', colorParams: { palette: (plugin.customState as any).colorPalette } }, { tag: 'polymer' }),
-        };
-
-        await update.commit({ revertOnError: true });
-        await shinyStyle(plugin);
-        plugin.managers.interactivity.setProps({ granularity: 'residue' });
-
-        return { components, representations };
-    }
-});
-
-export const IllustrativePreset = StructureRepresentationPresetProvider({
-    id: 'preset-illustrative',
-    display: { name: 'Illustrative' },
-    params: () => PresetParams,
-    async apply(ref, params, plugin) {
-        const structureCell = StateObjectRef.resolveAndCheck(plugin.state.data, ref);
-        if (!structureCell) return {};
-
-        const components = {
-            ligand: await presetStaticComponent(plugin, structureCell, 'ligand'),
-            polymer: await presetStaticComponent(plugin, structureCell, 'polymer'),
-        };
-
-        const { update, builder, typeParams } = StructureRepresentationPresetProvider.reprBuilder(plugin, params);
-        const representations = {
-            ligand: builder.buildRepresentation(update, components.ligand, { type: 'spacefill', typeParams: { ...typeParams, ignoreLight: true }, color: 'element-symbol', colorParams: { carbonColor: { name: 'element-symbol', params: {} } } }, { tag: 'ligand' }),
-            polymer: builder.buildRepresentation(update, components.polymer, { type: 'spacefill', typeParams: { ...typeParams, ignoreLight: true }, color: 'illustrative', colorParams: { palette: (plugin.customState as any).colorPalette } }, { tag: 'polymer' }),
-        };
-
-        await update.commit({ revertOnError: true });
-        await occlusionStyle(plugin);
-        plugin.managers.interactivity.setProps({ granularity: 'residue' });
-
-        return { components, representations };
-    }
-});
-
-const SurfacePreset = StructureRepresentationPresetProvider({
-    id: 'preset-surface',
-    display: { name: 'Surface' },
-    params: () => PresetParams,
-    async apply(ref, params, plugin) {
-        const structureCell = StateObjectRef.resolveAndCheck(plugin.state.data, ref);
-        const structure = structureCell?.obj?.data;
-        if (!structureCell || !structure) return {};
-
-        const components = {
-            ligand: await presetStaticComponent(plugin, structureCell, 'ligand'),
-            polymer: await presetStaticComponent(plugin, structureCell, 'polymer'),
-        };
-
-        const { update, builder, typeParams } = StructureRepresentationPresetProvider.reprBuilder(plugin, params);
-        const representations = {
-            ligand: builder.buildRepresentation(update, components.ligand, { type: 'ball-and-stick', typeParams: { ...typeParams, material: CustomMaterial, sizeFactor: 0.26 }, color: 'element-symbol', colorParams: { carbonColor: { name: 'element-symbol', params: {} } } }, { tag: 'ligand' }),
-            polymer: builder.buildRepresentation(update, components.polymer, { type: 'molecular-surface', typeParams: { ...typeParams, material: CustomMaterial, quality: 'custom', resolution: 0.5, doubleSided: true }, color: 'partial-charge' }, { tag: 'polymer' }),
-        };
-
-        await update.commit({ revertOnError: true });
-        await shinyStyle(plugin);
-        plugin.managers.interactivity.setProps({ granularity: 'residue' });
-
-        return { components, representations };
-    }
-});
-
-const PocketPreset = StructureRepresentationPresetProvider({
-    id: 'preset-pocket',
-    display: { name: 'Pocket' },
-    params: () => PresetParams,
-    async apply(ref, params, plugin) {
-        const structureCell = StateObjectRef.resolveAndCheck(plugin.state.data, ref);
-        const structure = structureCell?.obj?.data;
-        if (!structureCell || !structure) return {};
-
-        const components = {
-            ligand: await presetStaticComponent(plugin, structureCell, 'ligand'),
-            surroundings: await plugin.builders.structure.tryCreateComponentFromSelection(structureCell, ligandSurroundings, `surroundings`),
-        };
-
-        const { update, builder, typeParams } = StructureRepresentationPresetProvider.reprBuilder(plugin, params);
-        const representations = {
-            ligand: builder.buildRepresentation(update, components.ligand, { type: 'ball-and-stick', typeParams: { ...typeParams, material: CustomMaterial, sizeFactor: 0.26 }, color: 'element-symbol', colorParams: { carbonColor: { name: 'element-symbol', params: {} } } }, { tag: 'ligand' }),
-            surroundings: builder.buildRepresentation(update, components.surroundings, { type: 'molecular-surface', typeParams: { ...typeParams, material: CustomMaterial, includeParent: true, quality: 'custom', resolution: 0.2, doubleSided: true }, color: 'partial-charge' }, { tag: 'surroundings' }),
-        };
-
-        await update.commit({ revertOnError: true });
-        await shinyStyle(plugin);
-        plugin.managers.interactivity.setProps({ granularity: 'element' });
-
-        return { components, representations };
-    }
-});
-
-const InteractionsPreset = StructureRepresentationPresetProvider({
-    id: 'preset-interactions',
-    display: { name: 'Interactions' },
-    params: () => PresetParams,
-    async apply(ref, params, plugin) {
-        const structureCell = StateObjectRef.resolveAndCheck(plugin.state.data, ref);
-        const structure = structureCell?.obj?.data;
-        if (!structureCell || !structure) return {};
-
-        const components = {
-            ligand: await presetStaticComponent(plugin, structureCell, 'ligand'),
-            surroundings: await plugin.builders.structure.tryCreateComponentFromSelection(structureCell, ligandSurroundings, `surroundings`),
-            interactions: await presetStaticComponent(plugin, structureCell, 'ligand'),
-        };
-
-        const { update, builder, typeParams } = StructureRepresentationPresetProvider.reprBuilder(plugin, params);
-        const representations = {
-            ligand: builder.buildRepresentation(update, components.ligand, { type: 'ball-and-stick', typeParams: { ...typeParams, material: CustomMaterial, sizeFactor: 0.3 }, color: 'element-symbol', colorParams: { carbonColor: { name: 'element-symbol', params: {} } } }, { tag: 'ligand' }),
-            ballAndStick: builder.buildRepresentation(update, components.surroundings, { type: 'ball-and-stick', typeParams: { ...typeParams, material: CustomMaterial, sizeFactor: 0.1, sizeAspectRatio: 1 }, color: 'element-symbol', colorParams: { carbonColor: { name: 'element-symbol', params: {} } } }, { tag: 'ball-and-stick' }),
-            interactions: builder.buildRepresentation(update, components.interactions, { type: InteractionsRepresentationProvider, typeParams: { ...typeParams, material: CustomMaterial, includeParent: true, parentDisplay: 'between' }, color: InteractionTypeColorThemeProvider }, { tag: 'interactions' }),
-            label: builder.buildRepresentation(update, components.surroundings, { type: 'label', typeParams: { ...typeParams, material: CustomMaterial, background: false, borderWidth: 0.1 }, color: 'uniform', colorParams: { value: Color(0x000000) } }, { tag: 'label' }),
-        };
-
-        await update.commit({ revertOnError: true });
-        await shinyStyle(plugin);
-        plugin.managers.interactivity.setProps({ granularity: 'element' });
-
-        return { components, representations };
-    }
-});
-
-export const ShowButtons = PluginConfig.item('showButtons', true);
-
-export class ViewportComponent extends PluginUIComponent {
-    async _set(structures: readonly StructureRef[], preset: StructureRepresentationPresetProvider) {
-        await this.plugin.managers.structure.component.clear(structures);
-        await this.plugin.managers.structure.component.applyPreset(structures, preset);
-    }
-
-    set = async (preset: StructureRepresentationPresetProvider) => {
-        await this._set(this.plugin.managers.structure.hierarchy.selection.structures, preset);
-    };
-
-    structurePreset = () => this.set(StructurePreset);
-    illustrativePreset = () => this.set(IllustrativePreset);
-    surfacePreset = () => this.set(SurfacePreset);
-    pocketPreset = () => this.set(PocketPreset);
-    interactionsPreset = () => this.set(InteractionsPreset);
-
-    get showButtons() {
-        return this.plugin.config.get(ShowButtons);
-    }
-
-    render() {
-        const VPControls = this.plugin.spec.components?.viewport?.controls || ViewportControls;
-
-        return <>
-            <Viewport />
-            {this.showButtons && <div className='msp-viewport-top-left-controls'>
-                <div style={{ marginBottom: '4px' }}>
-                    <Button onClick={this.structurePreset} >Structure</Button>
-                </div>
-                <div style={{ marginBottom: '4px' }}>
-                    <Button onClick={this.illustrativePreset}>Illustrative</Button>
-                </div>
-                <div style={{ marginBottom: '4px' }}>
-                    <Button onClick={this.surfacePreset}>Surface</Button>
-                </div>
-                {/* <div style={{ marginBottom: '4px' }}>
-                    <Button onClick={this.pocketPreset}>Pocket</Button>
-                </div> */}
-                <div style={{ marginBottom: '4px' }}>
-                    <Button onClick={this.interactionsPreset}>Interactions</Button>
-                </div>
-            </div>}
-            <VPControls />
-            <BackgroundTaskProgress />
-            <div className='msp-highlight-toast-wrapper'>
-                <LociLabels />
-                <Toasts />
-            </div>
-        </>;
-    }
-}

src/apps/domain-annotation-server/mapping.ts

@@ -4,12 +4,12 @@
  * @author David Sehnal <david.sehnal@gmail.com>
  */
 
-import { Table } from '../../mol-data/db';
-import { CifWriter } from '../../mol-io/writer/cif';
-import * as S from './schemas';
+import { Table } from '../../mol-data/db'
+import { CifWriter } from '../../mol-io/writer/cif'
+import * as S from './schemas'
 // import { getCategoryInstanceProvider } from './utils'
 
-export function createMapping(allData: any) {
+export default function create(allData: any) {
     const mols = Object.keys(allData);
     const enc = CifWriter.createEncoder();
     enc.startDataBlock(mols[0]);
@@ -38,7 +38,7 @@ type MappingRow = Table.Row<S.mapping>;
 
 function writeDomain(enc: CifWriter.Encoder, domain: DomainAnnotation | undefined) {
     if (!domain) return;
-    enc.writeCategory({ name: `pdbx_${domain.name}_domain_annotation`, instance: () => CifWriter.Category.ofTable(domain.domains) });
+    enc.writeCategory({ name: `pdbx_${domain.name}_domain_annotation`, instance: () =>  CifWriter.Category.ofTable(domain.domains) });
     enc.writeCategory({ name: `pdbx_${domain.name}_domain_mapping`, instance: () => CifWriter.Category.ofTable(domain.mappings) });
 }
 

src/apps/domain-annotation-server/schemas.ts

@@ -4,21 +4,21 @@
  * @author David Sehnal <david.sehnal@gmail.com>
  */
 
-import { Column } from '../../mol-data/db';
+import { Column } from '../../mol-data/db'
 
 import Type = Column.Schema
 
 export const Sources = {
     id: Type.str,
     count: Type.int
-};
+}
 export type Sources = typeof Sources
 
 export const Base = {
     id: Type.str,
     identifier: Type.str,
     mapping_group_id: Type.int
-};
+}
 export type Base = typeof Base
 
 export const mapping = {
@@ -36,17 +36,17 @@ export const mapping = {
     end_label_seq_id: Type.int,
     end_auth_seq_id: Type.int,
     pdbx_end_PDB_ins_code: Type.str
-};
+}
 export type mapping = typeof mapping
 
 export const Pfam = {
     description: Type.str
-};
+}
 export type Pfam = typeof Pfam
 
 export const InterPro = {
     name: Type.str
-};
+}
 export type InterPro = typeof InterPro
 
 export const CATH = {
@@ -56,32 +56,32 @@ export const CATH = {
     identifier: Type.str,
     class: Type.str,
     topology: Type.str,
-};
+}
 export type CATH = typeof CATH
 
 export const EC = {
     accepted_name: Type.str,
     reaction: Type.str,
     systematic_name: Type.str
-};
+}
 export type EC = typeof EC
 
 export const UniProt = {
     name: Type.str
-};
+}
 export type UniProt = typeof UniProt
 
 export const SCOP = {
     sccs: Type.str,
     description: Type.str
-};
+}
 export type SCOP = typeof SCOP
 
 export const GO = {
     category: Type.str,
     definition: Type.str,
     name: Type.str
-};
+}
 export type GO = typeof GO
 
 export const categories = {
@@ -92,4 +92,4 @@ export const categories = {
     UniProt,
     SCOP,
     GO
-};
+}

src/apps/domain-annotation-server/server.ts

@@ -4,9 +4,9 @@
  * @author David Sehnal <david.sehnal@gmail.com>
  */
 
-import express from 'express';
-import fetch from 'node-fetch';
-import { createMapping } from './mapping';
+import * as express from 'express'
+import fetch from 'node-fetch'
+import createMapping from './mapping'
 
 async function getMappings(id: string) {
     const data = await fetch(`https://www.ebi.ac.uk/pdbe/api/mappings/${id}`);
@@ -15,11 +15,11 @@ async function getMappings(id: string) {
 };
 
 
-const PORT = process.env.port || 1338;
+let PORT = process.env.port || 1338;
 
 const app = express();
 
-const PREFIX = '/';
+const PREFIX = '/'
 
 app.get(`${PREFIX}/:id`, async (req, res) => {
     try {
@@ -41,7 +41,7 @@ app.get(`${PREFIX}/:id`, async (req, res) => {
 app.get(`${PREFIX}`, (req, res) => {
     res.writeHead(200, { 'Content-Type': 'text/plain; charset=utf-8' });
     res.end('Usage: /pdb_id, e.g. /1tqn');
-});
+})
 
 app.listen(PORT);
 

src/apps/domain-annotation-server/test.ts

@@ -4,8 +4,8 @@
  * @author David Sehnal <david.sehnal@gmail.com>
  */
 
-import fetch from 'node-fetch';
-import { createMapping } from './mapping';
+import fetch from 'node-fetch'
+import createMapping from './mapping'
 
 (async function () {
     const data = await fetch('https://www.ebi.ac.uk/pdbe/api/mappings/1tqn?pretty=true');

src/apps/model-server-query/index.html

@@ -0,0 +1,12 @@
+<!DOCTYPE html>
+<html lang="en">
+    <head>
+        <meta charset="utf-8" />
+        <meta name="viewport" content="width=device-width, user-scalable=no, minimum-scale=1.0, maximum-scale=1.0">
+        <title>Mol* ModelServer Query Builder</title>
+    </head>
+    <body>
+        <div id="app"></div>
+        <script type="text/javascript" src="./index.js"></script>
+    </body>
+</html>

src/apps/model-server-query/index.tsx

@@ -0,0 +1,134 @@
+/**
+ * Copyright (c) 2018 mol* contributors, licensed under MIT, See LICENSE file for more info.
+ *
+ * @author David Sehnal <david.sehnal@gmail.com>
+ */
+
+import * as React from 'react'
+import * as ReactDOM from 'react-dom'
+import * as Rx from 'rxjs'
+
+import { QueryDefinition, QueryList } from '../../servers/model/server/api'
+
+import './index.html'
+
+interface State {
+    query: Rx.BehaviorSubject<QueryDefinition>,
+    id: Rx.BehaviorSubject<string>,
+    params: Rx.BehaviorSubject<any>,
+    isBinary: Rx.BehaviorSubject<boolean>,
+    models: Rx.BehaviorSubject<number[]>,
+    url: Rx.Subject<string>
+}
+
+class Root extends React.Component<{ state: State }, {  }> {
+    render() {
+        return <div>
+            <div>
+                Query: <QuerySelect state={this.props.state} />
+            </div>
+            <div>
+                ID: <input type='text' onChange={t => this.props.state.id.next(t.currentTarget.value)} />
+            </div>
+            <div>
+                Params:<br/>
+                <QueryParams state={this.props.state} />
+            </div>
+            <div>
+                Model numbers (empty for all): <ModelNums state={this.props.state} />
+            </div>
+            <div>
+                <input type='checkbox' onChange={t => this.props.state.isBinary.next(!!t.currentTarget.checked)} /> Binary
+            </div>
+            <div>
+                Query string:
+                <QueryUrl state={this.props.state} />
+            </div>
+        </div>
+    }
+}
+
+class QuerySelect extends React.Component<{ state: State }> {
+    render() {
+        return <select onChange={s => this.props.state.query.next(QueryList[+s.currentTarget.value].definition)}>
+            { QueryList.map((q, i) => <option value={i} key={i} selected={i === 1}>{q.definition.niceName}</option>) }
+        </select>
+    }
+}
+
+class QueryParams extends React.Component<{ state: State }, { prms: string }> {
+    state = { prms: '' };
+
+    parseParams(str: string) {
+        this.setState({ prms: str });
+        try {
+            const params = JSON.parse(str);
+            this.props.state.params.next(params);
+        } catch {
+            this.props.state.params.next({});
+        }
+    }
+
+    componentDidMount() {
+        this.props.state.query.subscribe(q => this.setState({ prms: formatParams(q) }))
+    }
+
+    render() {
+        return <textarea style={{height: '300px'}} value={this.state.prms} cols={80} onChange={t => this.parseParams(t.currentTarget.value)} />;
+    }
+}
+
+class QueryUrl extends React.Component<{ state: State }, { queryString: string }> {
+    state = { queryString: '' };
+
+    componentDidMount() {
+        this.props.state.url.subscribe(url => this.setState({ queryString: url }))
+    }
+
+    render() {
+        return <input type='text' value={this.state.queryString} style={{ width: '800px' }} />
+    }
+}
+
+class ModelNums extends React.Component<{ state: State }> {
+    render() {
+        return <input type='text' defaultValue='1' style={{ width: '300px' }} onChange={t =>
+            this.props.state.models.next(t.currentTarget.value.split(',')
+                .map(v => v.trim())
+                .filter(v => !!v)
+                .map(v => +v)
+                )} />
+    }
+}
+
+const state: State = {
+    query: new Rx.BehaviorSubject(QueryList[1].definition),
+    id: new Rx.BehaviorSubject('1cbs'),
+    params: new Rx.BehaviorSubject({ }),
+    isBinary: new Rx.BehaviorSubject<boolean>(false),
+    models: new Rx.BehaviorSubject<number[]>([]),
+    url: new Rx.Subject()
+}
+
+function formatParams(def: QueryDefinition) {
+    const prms = Object.create(null);
+    for (const p of def.jsonParams) {
+        prms[p.name] = p.exampleValues ? p.exampleValues[0] : void 0;
+    }
+    return JSON.stringify(prms, void 0, 2);
+}
+
+function formatUrl() {
+    const json = JSON.stringify({
+        name: state.query.value.name,
+        id: state.id.value,
+        modelNums: state.models.value.length ? state.models.value : void 0,
+        binary: state.isBinary.value,
+        params: state.params.value
+    });
+    state.url.next(encodeURIComponent(json));
+}
+
+Rx.merge(state.query, state.id, state.params, state.isBinary, state.models).subscribe(s => formatUrl());
+
+ReactDOM.render(<Root state={state} />, document.getElementById('app'));

src/apps/state-docs/index.ts

@@ -1,11 +1,10 @@
-#!/usr/bin/env node
 /**
  * Copyright (c) 2018 mol* contributors, licensed under MIT, See LICENSE file for more info.
  *
  * @author David Sehnal <david.sehnal@gmail.com>
  */
 
-import * as _ from '../../mol-plugin-state/transforms';
+import * as _ from '../../mol-plugin/state/transforms'
 import { StateTransformer, StateObject } from '../../mol-state';
 import { StringBuilder } from '../../mol-util';
 import * as fs from 'fs';
@@ -14,10 +13,11 @@ import { PluginContext } from '../../mol-plugin/context';
 import { ParamDefinition } from '../../mol-util/param-definition';
 
 // force the transform to be evaluated
-_.StateTransforms.Data.Download.id;
+_.StateTransforms.Data.Download.id
 
 // Empty plugin context
 const ctx = new PluginContext({
+    actions: [],
     behaviors: []
 });
 
@@ -32,7 +32,7 @@ function writeTransformer(t: StateTransformer) {
     StringBuilder.write(builder, `## <a name="${t.id.replace('.', '-')}"></a>${t.id} :: ${typeToString(t.definition.from)} -> ${typeToString(t.definition.to)}`);
     StringBuilder.newline(builder);
     if (t.definition.display.description) {
-        StringBuilder.write(builder, `*${t.definition.display.description}*`);
+        StringBuilder.write(builder, `*${t.definition.display.description}*`)
         StringBuilder.newline(builder);
     }
     StringBuilder.newline(builder);
@@ -48,7 +48,7 @@ function writeTransformer(t: StateTransformer) {
         StringBuilder.write(builder, `\`\`\`js\n${JSON.stringify(ParamDefinition.getDefaultValues(params), null, 2)}\n\`\`\``);
         StringBuilder.newline(builder);
     }
-    StringBuilder.write(builder, '----------------------------');
+    StringBuilder.write(builder, '----------------------------')
     StringBuilder.newline(builder);
 }
 
@@ -62,7 +62,7 @@ transformers.forEach(t => {
     StringBuilder.newline(builder);
 });
 StringBuilder.newline(builder);
-StringBuilder.write(builder, '----------------------------');
+StringBuilder.write(builder, '----------------------------')
 StringBuilder.newline(builder);
 transformers.forEach(t => writeTransformer(t));
 

src/apps/state-docs/pd-to-md.ts

@@ -19,15 +19,10 @@ function paramInfo(param: PD.Any, offset: number): string {
         case 'conditioned': return getParams(param.conditionParams, offset);
         case 'multi-select': return `Array of ${oToS(param.options)}`;
         case 'color': return 'Color as 0xrrggbb';
-        case 'color-list': return `A list of colors as 0xrrggbb`;
+        case 'color-list': return `One of ${oToS(param.options)}`;
         case 'vec3': return `3D vector [x, y, z]`;
-        case 'mat4': return `4x4 transformation matrix`;
-        case 'url': return `URL couple with unique identifier`;
         case 'file': return `JavaScript File Handle`;
-        case 'file-list': return `JavaScript FileList Handle`;
         case 'select': return `One of ${oToS(param.options)}`;
-        case 'value-ref': return `Reference to a runtime defined value.`;
-        case 'data-ref': return `Reference to a computed data value.`;
         case 'text': return 'String';
         case 'interval': return `Interval [min, max]`;
         case 'group': return `Object with:\n${getParams(param.params, offset + 2)}`;
@@ -43,7 +38,7 @@ function paramInfo(param: PD.Any, offset: number): string {
     }
 }
 
-function oToS(options: readonly (readonly [string, string] | readonly [string, string, string | undefined])[]) {
+function oToS(options: [string, string][]) {
     return options.map(o => `'${o[0]}'`).join(', ');
 }
 

src/apps/structure-info/helpers.ts

@@ -4,19 +4,19 @@
  * @author David Sehnal <david.sehnal@gmail.com>
  */
 
-import * as util from 'util';
-import * as fs from 'fs';
-import fetch from 'node-fetch';
+import * as util from 'util'
+import * as fs from 'fs'
+import fetch from 'node-fetch'
 require('util.promisify').shim();
 
-import { CIF } from '../../mol-io/reader/cif';
-import { Progress } from '../../mol-task';
+import { CIF } from '../../mol-io/reader/cif'
+import { Progress } from '../../mol-task'
 
 const readFileAsync = util.promisify(fs.readFile);
 
 async function readFile(path: string) {
     if (path.match(/\.bcif$/)) {
-        const input = await readFileAsync(path);
+        const input = await readFileAsync(path)
         const data = new Uint8Array(input.byteLength);
         for (let i = 0; i < input.byteLength; i++) data[i] = input[i];
         return data;

src/apps/structure-info/model.ts

@@ -1,4 +1,3 @@
-#!/usr/bin/env node
 /**
  * Copyright (c) 2018 mol* contributors, licensed under MIT, See LICENSE file for more info.
  *
@@ -6,20 +5,17 @@
  * @author David Sehnal <david.sehnal@gmail.com>
  */
 
-import * as argparse from 'argparse';
+import * as argparse from 'argparse'
 require('util.promisify').shim();
 
-import { CifFrame } from '../../mol-io/reader/cif';
-import { Model, Structure, StructureElement, Unit, StructureProperties, UnitRing, Trajectory } from '../../mol-model/structure';
+import { CifFrame } from '../../mol-io/reader/cif'
+import { Model, Structure, StructureElement, Unit, StructureProperties, UnitRing } from '../../mol-model/structure'
 // import { Run, Progress } from '../../mol-task'
 import { OrderedSet } from '../../mol-data/int';
 import { openCif, downloadCif } from './helpers';
 import { Vec3 } from '../../mol-math/linear-algebra';
 import { trajectoryFromMmCIF } from '../../mol-model-formats/structure/mmcif';
 import { Sequence } from '../../mol-model/sequence';
-import { ModelSecondaryStructure } from '../../mol-model-formats/structure/property/secondary-structure';
-import { ModelSymmetry } from '../../mol-model-formats/structure/property/symmetry';
-import { Task } from '../../mol-task';
 
 
 async function downloadFromPdb(pdb: string) {
@@ -34,36 +30,32 @@ export async function readCifFile(path: string) {
 }
 
 export function atomLabel(model: Model, aI: number) {
-    const { atoms, residues, chains, residueAtomSegments, chainAtomSegments } = model.atomicHierarchy;
-    const { label_atom_id, label_comp_id } = atoms;
-    const { label_seq_id } = residues;
-    const { label_asym_id } = chains;
-    const rI = residueAtomSegments.index[aI];
-    const cI = chainAtomSegments.index[aI];
-    return `${label_asym_id.value(cI)} ${label_comp_id.value(aI)} ${label_seq_id.value(rI)} ${label_atom_id.value(aI)}`;
+    const { atoms, residues, chains, residueAtomSegments, chainAtomSegments } = model.atomicHierarchy
+    const { label_atom_id } = atoms
+    const { label_comp_id, label_seq_id } = residues
+    const { label_asym_id } = chains
+    const rI = residueAtomSegments.index[aI]
+    const cI = chainAtomSegments.index[aI]
+    return `${label_asym_id.value(cI)} ${label_comp_id.value(rI)} ${label_seq_id.value(rI)} ${label_atom_id.value(aI)}`
 }
 
 export function residueLabel(model: Model, rI: number) {
-    const { atoms, residues, chains, residueAtomSegments, chainAtomSegments } = model.atomicHierarchy;
-    const { label_comp_id } = atoms;
-    const { label_seq_id } = residues;
-    const { label_asym_id } = chains;
-    const aI = residueAtomSegments.offsets[rI];
-    const cI = chainAtomSegments.index[aI];
-    return `${label_asym_id.value(cI)} ${label_comp_id.value(aI)} ${label_seq_id.value(rI)}`;
+    const { residues, chains, residueAtomSegments, chainAtomSegments } = model.atomicHierarchy
+    const { label_comp_id, label_seq_id } = residues
+    const { label_asym_id } = chains
+    const cI = chainAtomSegments.index[residueAtomSegments.offsets[rI]]
+    return `${label_asym_id.value(cI)} ${label_comp_id.value(rI)} ${label_seq_id.value(rI)}`
 }
 
 export function printSecStructure(model: Model) {
     console.log('\nSecondary Structure\n=============');
     const { residues } = model.atomicHierarchy;
-    const secondaryStructure = ModelSecondaryStructure.Provider.get(model);
-    if (!secondaryStructure) return;
+    const { key, elements } = model.properties.secondaryStructure;
 
-    const { key, elements } = secondaryStructure;
     const count = residues._rowCount;
     let rI = 0;
     while (rI < count) {
-        const start = rI;
+        let start = rI;
         while (rI < count && key[start] === key[rI]) rI++;
         rI--;
 
@@ -73,14 +65,14 @@ export function printSecStructure(model: Model) {
     }
 }
 
-export function printBonds(structure: Structure, showIntra: boolean, showInter: boolean) {
+export function printLinks(structure: Structure, showIntra: boolean, showInter: boolean) {
     if (showIntra) {
-        console.log('\nIntra Unit Bonds\n=============');
+        console.log('\nIntra Unit Links\n=============');
         for (const unit of structure.units) {
             if (!Unit.isAtomic(unit)) continue;
 
             const elements = unit.elements;
-            const { a, b, edgeCount } = unit.bonds;
+            const { a, b, edgeCount } = unit.links;
             const { model } = unit;
 
             if (!edgeCount) continue;
@@ -94,22 +86,20 @@ export function printBonds(structure: Structure, showIntra: boolean, showInter:
     }
 
     if (showInter) {
-        console.log('\nInter Unit Bonds\n=============');
-        const bonds = structure.interUnitBonds;
+        console.log('\nInter Unit Links\n=============');
+        const links = structure.links;
         for (const unit of structure.units) {
             if (!Unit.isAtomic(unit)) continue;
 
-            for (const pairBonds of bonds.getConnectedUnits(unit.id)) {
-                if (!pairBonds.areUnitsOrdered || pairBonds.edgeCount === 0) continue;
+            for (const pairLinks of links.getLinkedUnits(unit)) {
+                if (!pairLinks.areUnitsOrdered || pairLinks.bondCount === 0) continue;
 
-                const { unitA, unitB, edgeCount } = pairBonds;
-                const uA = structure.unitMap.get(unitA);
-                const uB = structure.unitMap.get(unitB);
-                console.log(`${unitA} - ${unitB}: ${edgeCount} bond(s)`);
+                const { unitA, unitB } = pairLinks;
+                console.log(`${pairLinks.unitA.id} - ${pairLinks.unitB.id}: ${pairLinks.bondCount} bond(s)`);
 
-                for (const aI of pairBonds.connectedIndices) {
-                    for (const bond of pairBonds.getEdges(aI)) {
-                        console.log(`${atomLabel(uA.model, uA.elements[aI])} -- ${atomLabel(uB.model, uB.elements[bond.indexB])}`);
+                for (const aI of pairLinks.linkedElementIndices) {
+                    for (const link of pairLinks.getBonds(aI)) {
+                        console.log(`${atomLabel(unitA.model, unitA.elements[aI])} -- ${atomLabel(unitB.model, unitB.elements[link.indexB])}`);
                     }
                 }
             }
@@ -122,13 +112,25 @@ export function printSequence(model: Model) {
     const { byEntityKey } = model.sequence;
     for (const key of Object.keys(byEntityKey)) {
         const { sequence, entityId } = byEntityKey[+key];
-        const { seqId, compId } = sequence;
-        console.log(`${entityId} (${sequence.kind} ${seqId.value(0)}, ${seqId.value(seqId.rowCount - 1)}) (${compId.value(0)}, ${compId.value(compId.rowCount - 1)})`);
+        const { seqId, compId } = sequence
+        console.log(`${entityId} (${sequence.kind} ${seqId.value(0)} (offset ${sequence.offset}), ${seqId.value(seqId.rowCount - 1)}) (${compId.value(0)}, ${compId.value(compId.rowCount - 1)})`);
         console.log(`${Sequence.getSequenceString(sequence)}`);
     }
     console.log();
 }
 
+export function printModRes(model: Model) {
+    console.log('\nModified Residues\n=============');
+    const map = model.properties.modifiedResidues.parentId;
+    const { label_comp_id, _rowCount } = model.atomicHierarchy.residues;
+    for (let i = 0; i < _rowCount; i++) {
+        const comp_id = label_comp_id.value(i);
+        if (!map.has(comp_id)) continue;
+        console.log(`[${i}] ${map.get(comp_id)} -> ${comp_id}`);
+    }
+    console.log();
+}
+
 export function printRings(structure: Structure) {
     console.log('\nRings\n=============');
     for (const unit of structure.units) {
@@ -138,7 +140,7 @@ export function printRings(structure: Structure) {
         for (let i = 0, _i = Math.min(5, all.length); i < _i; i++) {
             fps[fps.length] = UnitRing.fingerprint(unit, all[i]);
         }
-        if (all.length > 5) fps.push('...');
+        if (all.length > 5) fps.push('...')
         console.log(`Unit ${unit.id}, ${all.length} ring(s), ${byFingerprint.size} different fingerprint(s).\n  ${fps.join(', ')}`);
     }
     console.log();
@@ -146,7 +148,7 @@ export function printRings(structure: Structure) {
 
 export function printUnits(structure: Structure) {
     console.log('\nUnits\n=============');
-    const l = StructureElement.Location.create(structure);
+    const l = StructureElement.Location.create();
 
     for (const unit of structure.units) {
         l.unit = unit;
@@ -177,8 +179,7 @@ export function printUnits(structure: Structure) {
 
 export function printSymmetryInfo(model: Model) {
     console.log('\nSymmetry Info\n=============');
-    const symmetry = ModelSymmetry.Provider.get(model);
-    if (!symmetry) return;
+    const { symmetry } = model;
     const { size, anglesInRadians } = symmetry.spacegroup.cell;
     console.log(`Spacegroup: ${symmetry.spacegroup.name} size: ${Vec3.toString(size)} angles: ${Vec3.toString(anglesInRadians)}`);
     console.log(`Assembly names: ${symmetry.assemblies.map(a => a.id).join(', ')}`);
@@ -186,11 +187,10 @@ export function printSymmetryInfo(model: Model) {
     console.log(`NCS operators: ${symmetry.ncsOperators && symmetry.ncsOperators.map(a => a.name).join(', ')}`);
 }
 
-export async function printModelStats(models: Trajectory) {
+export function printModelStats(models: ReadonlyArray<Model>) {
     console.log('\nModels\n=============');
 
-    for (let i = 0; i < models.frameCount; i++) {
-        const m = await Task.resolveInContext(models.getFrameAtIndex(i));
+    for (const m of models) {
         if (m.coarseHierarchy.isDefined) {
             console.log(`${m.label} ${m.modelNum}: ${m.atomicHierarchy.atoms._rowCount} atom(s), ${m.coarseHierarchy.spheres.count} sphere(s), ${m.coarseHierarchy.gaussians.count} gaussian(s)`);
         } else {
@@ -202,7 +202,7 @@ export async function printModelStats(models: Trajectory) {
 
 export async function getModelsAndStructure(frame: CifFrame) {
     const models = await trajectoryFromMmCIF(frame).run();
-    const structure = Structure.ofModel(models.representative);
+    const structure = Structure.ofModel(models[0]);
     return { models, structure };
 }
 
@@ -210,17 +210,18 @@ async function run(frame: CifFrame, args: Args) {
     const { models, structure } = await getModelsAndStructure(frame);
 
     if (args.models) printModelStats(models);
-    if (args.seq) printSequence(models.representative);
+    if (args.seq) printSequence(models[0]);
     if (args.units) printUnits(structure);
-    if (args.sym) printSymmetryInfo(models.representative);
+    if (args.sym) printSymmetryInfo(models[0]);
     if (args.rings) printRings(structure);
-    if (args.intraBonds) printBonds(structure, true, false);
-    if (args.interBonds) printBonds(structure, false, true);
-    if (args.sec) printSecStructure(models.representative);
+    if (args.intraLinks) printLinks(structure, true, false);
+    if (args.interLinks) printLinks(structure, false, true);
+    if (args.mod) printModRes(models[0]);
+    if (args.sec) printSecStructure(models[0]);
 }
 
 async function runDL(pdb: string, args: Args) {
-    const mmcif = await downloadFromPdb(pdb);
+    const mmcif = await downloadFromPdb(pdb)
     run(mmcif, args);
 }
 
@@ -230,21 +231,21 @@ async function runFile(filename: string, args: Args) {
 }
 
 const parser = new argparse.ArgumentParser({
-    add_help: true,
+    addHelp: true,
     description: 'Print info about a structure, mainly to test and showcase the mol-model module'
 });
-parser.add_argument('--download', '-d', { help: 'Pdb entry id' });
-parser.add_argument('--file', '-f', { help: 'filename' });
+parser.addArgument(['--download', '-d'], { help: 'Pdb entry id' });
+parser.addArgument(['--file', '-f'], { help: 'filename' });
 
-parser.add_argument('--models', { help: 'print models info', action: 'store_true' });
-parser.add_argument('--seq', { help: 'print sequence', action: 'store_true' });
-parser.add_argument('--units', { help: 'print units', action: 'store_true' });
-parser.add_argument('--sym', { help: 'print symmetry', action: 'store_true' });
-parser.add_argument('--rings', { help: 'print rings', action: 'store_true' });
-parser.add_argument('--intraBonds', { help: 'print intra unit bonds', action: 'store_true' });
-parser.add_argument('--interBonds', { help: 'print inter unit bonds', action: 'store_true' });
-parser.add_argument('--mod', { help: 'print modified residues', action: 'store_true' });
-parser.add_argument('--sec', { help: 'print secoundary structure', action: 'store_true' });
+parser.addArgument(['--models'], { help: 'print models info', action: 'storeTrue' });
+parser.addArgument(['--seq'], { help: 'print sequence', action: 'storeTrue' });
+parser.addArgument(['--units'], { help: 'print units', action: 'storeTrue' });
+parser.addArgument(['--sym'], { help: 'print symmetry', action: 'storeTrue' });
+parser.addArgument(['--rings'], { help: 'print rings', action: 'storeTrue' });
+parser.addArgument(['--intraLinks'], { help: 'print intra unit links', action: 'storeTrue' });
+parser.addArgument(['--interLinks'], { help: 'print inter unit links', action: 'storeTrue' });
+parser.addArgument(['--mod'], { help: 'print modified residues', action: 'storeTrue' });
+parser.addArgument(['--sec'], { help: 'print secoundary structure', action: 'storeTrue' });
 interface Args {
     download?: string,
     file?: string,
@@ -255,12 +256,12 @@ interface Args {
     units?: boolean,
     sym?: boolean,
     rings?: boolean,
-    intraBonds?: boolean,
-    interBonds?: boolean,
+    intraLinks?: boolean,
+    interLinks?: boolean,
     mod?: boolean,
     sec?: boolean,
 }
-const args: Args = parser.parse_args();
+const args: Args = parser.parseArgs();
 
-if (args.download) runDL(args.download, args);
-else if (args.file) runFile(args.file, args);
+if (args.download) runDL(args.download, args)
+else if (args.file) runFile(args.file, args)

src/apps/structure-info/volume.ts

@@ -1,44 +1,46 @@
-#!/usr/bin/env node
 /**
  * Copyright (c) 2018 mol* contributors, licensed under MIT, See LICENSE file for more info.
  *
  * @author David Sehnal <david.sehnal@gmail.com>
  */
 
-import * as fs from 'fs';
-import * as argparse from 'argparse';
-import * as util from 'util';
+import * as fs from 'fs'
+import * as argparse from 'argparse'
+import * as util from 'util'
 
-import { Volume } from '../../mol-model/volume';
-import { downloadCif } from './helpers';
-import { CIF } from '../../mol-io/reader/cif';
+import { VolumeData, VolumeIsoValue } from '../../mol-model/volume'
+import { downloadCif } from './helpers'
+import { CIF } from '../../mol-io/reader/cif'
+import { DensityServer_Data_Database } from '../../mol-io/reader/cif/schema/density-server';
 import { Table } from '../../mol-data/db';
 import { StringBuilder } from '../../mol-util';
 import { Task } from '../../mol-task';
 import { createVolumeIsosurfaceMesh } from '../../mol-repr/volume/isosurface';
-import { Theme } from '../../mol-theme/theme';
-import { volumeFromDensityServerData, DscifFormat } from '../../mol-model-formats/volume/density-server';
+import { createEmptyTheme } from '../../mol-theme/theme';
+import { volumeFromDensityServerData } from '../../mol-model-formats/volume/density-server';
 
 require('util.promisify').shim();
 const writeFileAsync = util.promisify(fs.writeFile);
 
+type Volume = { source: DensityServer_Data_Database, volume: VolumeData }
+
 async function getVolume(url: string): Promise<Volume> {
     const cif = await downloadCif(url, true);
     const data = CIF.schema.densityServer(cif.blocks[1]);
-    return await volumeFromDensityServerData(data).run();
+    return { source: data, volume: await volumeFromDensityServerData(data).run() };
 }
 
-function print(volume: Volume) {
-    if (!DscifFormat.is(volume.sourceData)) return;
-    const { volume_data_3d_info } = volume.sourceData.data;
+function print(data: Volume) {
+    const { volume_data_3d_info } = data.source;
     const row = Table.getRow(volume_data_3d_info, 0);
     console.log(row);
-    console.log(volume.grid.transform);
-    console.log(volume.grid.stats);
+    console.log(data.volume.cell);
+    console.log(data.volume.dataStats);
+    console.log(data.volume.fractionalBox);
 }
 
-async function doMesh(volume: Volume, filename: string) {
-    const mesh = await Task.create('', runtime => createVolumeIsosurfaceMesh({ runtime }, volume, Theme.createEmpty(), { isoValue: Volume.IsoValue.absolute(1.5) })).run();
+async function doMesh(data: Volume, filename: string) {
+    const mesh = await Task.create('', runtime => createVolumeIsosurfaceMesh({ runtime }, data.volume, createEmptyTheme(), { isoValue: VolumeIsoValue.absolute(1.5) } )).run();
     console.log({ vc: mesh.vertexCount, tc: mesh.triangleCount });
 
     // Export the mesh in OBJ format.
@@ -75,13 +77,13 @@ async function run(url: string, meshFilename: string) {
 }
 
 const parser = new argparse.ArgumentParser({
-    add_help: true,
-    description: 'Info about VolumeData from mol-model module'
+addHelp: true,
+description: 'Info about VolumeData from mol-model module'
 });
-parser.add_argument('--emdb', '-e', {
+parser.addArgument([ '--emdb', '-e' ], {
     help: 'EMDB id, for example 8116',
 });
-parser.add_argument('--mesh', {
+parser.addArgument([ '--mesh' ], {
     help: 'Mesh filename',
     required: true
 });
@@ -89,6 +91,6 @@ interface Args {
     emdb?: string,
     mesh: string
 }
-const args: Args = parser.parse_args();
+const args: Args = parser.parseArgs();
 
 run(`https://ds.litemol.org/em/emd-${args.emdb}/cell?detail=4`, args.mesh);

src/apps/viewer/app.ts

@@ -1,504 +0,0 @@
-/**
- * Copyright (c) 2018-2022 mol* contributors, licensed under MIT, See LICENSE file for more info.
- *
- * @author David Sehnal <david.sehnal@gmail.com>
- * @author Alexander Rose <alexander.rose@weirdbyte.de>
- */
-
-import { ANVILMembraneOrientation } from '../../extensions/anvil/behavior';
-import { CellPack } from '../../extensions/cellpack';
-import { DnatcoConfalPyramids } from '../../extensions/dnatco';
-import { G3DFormat, G3dProvider } from '../../extensions/g3d/format';
-import { GeometryExport } from '../../extensions/geo-export';
-import { MAQualityAssessment } from '../../extensions/model-archive/quality-assessment/behavior';
-import { QualityAssessmentPLDDTPreset, QualityAssessmentQmeanPreset } from '../../extensions/model-archive/quality-assessment/behavior';
-import { QualityAssessment } from '../../extensions/model-archive/quality-assessment/prop';
-import { ModelExport } from '../../extensions/model-export';
-import { Mp4Export } from '../../extensions/mp4-export';
-import { PDBeStructureQualityReport } from '../../extensions/pdbe';
-import { RCSBAssemblySymmetry, RCSBValidationReport } from '../../extensions/rcsb';
-import { ZenodoImport } from '../../extensions/zenodo';
-import { Volume } from '../../mol-model/volume';
-import { DownloadStructure, PdbDownloadProvider } from '../../mol-plugin-state/actions/structure';
-import { DownloadDensity } from '../../mol-plugin-state/actions/volume';
-import { PresetTrajectoryHierarchy } from '../../mol-plugin-state/builder/structure/hierarchy-preset';
-import { PresetStructureRepresentations, StructureRepresentationPresetProvider } from '../../mol-plugin-state/builder/structure/representation-preset';
-import { DataFormatProvider } from '../../mol-plugin-state/formats/provider';
-import { BuiltInTopologyFormat } from '../../mol-plugin-state/formats/topology';
-import { BuiltInCoordinatesFormat } from '../../mol-plugin-state/formats/coordinates';
-import { BuiltInTrajectoryFormat } from '../../mol-plugin-state/formats/trajectory';
-import { BuildInVolumeFormat } from '../../mol-plugin-state/formats/volume';
-import { createVolumeRepresentationParams } from '../../mol-plugin-state/helpers/volume-representation-params';
-import { PluginStateObject } from '../../mol-plugin-state/objects';
-import { StateTransforms } from '../../mol-plugin-state/transforms';
-import { TrajectoryFromModelAndCoordinates } from '../../mol-plugin-state/transforms/model';
-import { createPluginUI } from '../../mol-plugin-ui/react18';
-import { PluginUIContext } from '../../mol-plugin-ui/context';
-import { DefaultPluginUISpec, PluginUISpec } from '../../mol-plugin-ui/spec';
-import { PluginCommands } from '../../mol-plugin/commands';
-import { PluginConfig } from '../../mol-plugin/config';
-import { PluginLayoutControlsDisplay } from '../../mol-plugin/layout';
-import { PluginSpec } from '../../mol-plugin/spec';
-import { PluginState } from '../../mol-plugin/state';
-import { StateObjectRef, StateObjectSelector } from '../../mol-state';
-import { Asset } from '../../mol-util/assets';
-import { Color } from '../../mol-util/color';
-import '../../mol-util/polyfill';
-import { ObjectKeys } from '../../mol-util/type-helpers';
-import { SaccharideCompIdMapType } from '../../mol-model/structure/structure/carbohydrates/constants';
-import { Backgrounds } from '../../extensions/backgrounds';
-
-export { PLUGIN_VERSION as version } from '../../mol-plugin/version';
-export { setDebugMode, setProductionMode, setTimingMode } from '../../mol-util/debug';
-
-const CustomFormats = [
-    ['g3d', G3dProvider] as const
-];
-
-const Extensions = {
-    'backgrounds': PluginSpec.Behavior(Backgrounds),
-    'cellpack': PluginSpec.Behavior(CellPack),
-    'dnatco-confal-pyramids': PluginSpec.Behavior(DnatcoConfalPyramids),
-    'pdbe-structure-quality-report': PluginSpec.Behavior(PDBeStructureQualityReport),
-    'rcsb-assembly-symmetry': PluginSpec.Behavior(RCSBAssemblySymmetry),
-    'rcsb-validation-report': PluginSpec.Behavior(RCSBValidationReport),
-    'anvil-membrane-orientation': PluginSpec.Behavior(ANVILMembraneOrientation),
-    'g3d': PluginSpec.Behavior(G3DFormat),
-    'model-export': PluginSpec.Behavior(ModelExport),
-    'mp4-export': PluginSpec.Behavior(Mp4Export),
-    'geo-export': PluginSpec.Behavior(GeometryExport),
-    'ma-quality-assessment': PluginSpec.Behavior(MAQualityAssessment),
-    'zenodo-import': PluginSpec.Behavior(ZenodoImport),
-};
-
-const DefaultViewerOptions = {
-    customFormats: CustomFormats as [string, DataFormatProvider][],
-    extensions: ObjectKeys(Extensions),
-    layoutIsExpanded: true,
-    layoutShowControls: true,
-    layoutShowRemoteState: true,
-    layoutControlsDisplay: 'reactive' as PluginLayoutControlsDisplay,
-    layoutShowSequence: true,
-    layoutShowLog: true,
-    layoutShowLeftPanel: true,
-    collapseLeftPanel: false,
-    collapseRightPanel: false,
-    disableAntialiasing: PluginConfig.General.DisableAntialiasing.defaultValue,
-    pixelScale: PluginConfig.General.PixelScale.defaultValue,
-    pickScale: PluginConfig.General.PickScale.defaultValue,
-    pickPadding: PluginConfig.General.PickPadding.defaultValue,
-    enableWboit: PluginConfig.General.EnableWboit.defaultValue,
-    enableDpoit: PluginConfig.General.EnableDpoit.defaultValue,
-    preferWebgl1: PluginConfig.General.PreferWebGl1.defaultValue,
-    allowMajorPerformanceCaveat: PluginConfig.General.AllowMajorPerformanceCaveat.defaultValue,
-
-    viewportShowExpand: PluginConfig.Viewport.ShowExpand.defaultValue,
-    viewportShowControls: PluginConfig.Viewport.ShowControls.defaultValue,
-    viewportShowSettings: PluginConfig.Viewport.ShowSettings.defaultValue,
-    viewportShowSelectionMode: PluginConfig.Viewport.ShowSelectionMode.defaultValue,
-    viewportShowAnimation: PluginConfig.Viewport.ShowAnimation.defaultValue,
-    viewportShowTrajectoryControls: PluginConfig.Viewport.ShowTrajectoryControls.defaultValue,
-    pluginStateServer: PluginConfig.State.DefaultServer.defaultValue,
-    volumeStreamingServer: PluginConfig.VolumeStreaming.DefaultServer.defaultValue,
-    volumeStreamingDisabled: !PluginConfig.VolumeStreaming.Enabled.defaultValue,
-    pdbProvider: PluginConfig.Download.DefaultPdbProvider.defaultValue,
-    emdbProvider: PluginConfig.Download.DefaultEmdbProvider.defaultValue,
-    saccharideCompIdMapType: 'default' as SaccharideCompIdMapType,
-};
-type ViewerOptions = typeof DefaultViewerOptions;
-
-export class Viewer {
-    constructor(public plugin: PluginUIContext) {
-    }
-
-    static async create(elementOrId: string | HTMLElement, options: Partial<ViewerOptions> = {}) {
-        const definedOptions = {} as any;
-        // filter for defined properies only so the default values
-        // are property applied
-        for (const p of Object.keys(options) as (keyof ViewerOptions)[]) {
-            if (options[p] !== void 0) definedOptions[p] = options[p];
-        }
-
-        const o: ViewerOptions = { ...DefaultViewerOptions, ...definedOptions };
-        const defaultSpec = DefaultPluginUISpec();
-
-        const spec: PluginUISpec = {
-            actions: defaultSpec.actions,
-            behaviors: [
-                ...defaultSpec.behaviors,
-                ...o.extensions.map(e => Extensions[e]),
-            ],
-            animations: [...defaultSpec.animations || []],
-            customParamEditors: defaultSpec.customParamEditors,
-            customFormats: o?.customFormats,
-            layout: {
-                initial: {
-                    isExpanded: o.layoutIsExpanded,
-                    showControls: o.layoutShowControls,
-                    controlsDisplay: o.layoutControlsDisplay,
-                    regionState: {
-                        bottom: 'full',
-                        left: o.collapseLeftPanel ? 'collapsed' : 'full',
-                        right: o.collapseRightPanel ? 'hidden' : 'full',
-                        top: 'full',
-                    }
-                },
-            },
-            components: {
-                ...defaultSpec.components,
-                controls: {
-                    ...defaultSpec.components?.controls,
-                    top: o.layoutShowSequence ? undefined : 'none',
-                    bottom: o.layoutShowLog ? undefined : 'none',
-                    left: o.layoutShowLeftPanel ? undefined : 'none',
-                },
-                remoteState: o.layoutShowRemoteState ? 'default' : 'none',
-            },
-            config: [
-                [PluginConfig.General.DisableAntialiasing, o.disableAntialiasing],
-                [PluginConfig.General.PixelScale, o.pixelScale],
-                [PluginConfig.General.PickScale, o.pickScale],
-                [PluginConfig.General.PickPadding, o.pickPadding],
-                [PluginConfig.General.EnableWboit, o.enableWboit],
-                [PluginConfig.General.EnableDpoit, o.enableDpoit],
-                [PluginConfig.General.PreferWebGl1, o.preferWebgl1],
-                [PluginConfig.General.AllowMajorPerformanceCaveat, o.allowMajorPerformanceCaveat],
-                [PluginConfig.Viewport.ShowExpand, o.viewportShowExpand],
-                [PluginConfig.Viewport.ShowControls, o.viewportShowControls],
-                [PluginConfig.Viewport.ShowSettings, o.viewportShowSettings],
-                [PluginConfig.Viewport.ShowSelectionMode, o.viewportShowSelectionMode],
-                [PluginConfig.Viewport.ShowAnimation, o.viewportShowAnimation],
-                [PluginConfig.Viewport.ShowTrajectoryControls, o.viewportShowTrajectoryControls],
-                [PluginConfig.State.DefaultServer, o.pluginStateServer],
-                [PluginConfig.State.CurrentServer, o.pluginStateServer],
-                [PluginConfig.VolumeStreaming.DefaultServer, o.volumeStreamingServer],
-                [PluginConfig.VolumeStreaming.Enabled, !o.volumeStreamingDisabled],
-                [PluginConfig.Download.DefaultPdbProvider, o.pdbProvider],
-                [PluginConfig.Download.DefaultEmdbProvider, o.emdbProvider],
-                [PluginConfig.Structure.DefaultRepresentationPreset, ViewerAutoPreset.id],
-                [PluginConfig.Structure.SaccharideCompIdMapType, o.saccharideCompIdMapType],
-            ]
-        };
-
-        const element = typeof elementOrId === 'string'
-            ? document.getElementById(elementOrId)
-            : elementOrId;
-        if (!element) throw new Error(`Could not get element with id '${elementOrId}'`);
-        const plugin = await createPluginUI(element, spec, {
-            onBeforeUIRender: plugin => {
-                // the preset needs to be added before the UI renders otherwise
-                // "Download Structure" wont be able to pick it up
-                plugin.builders.structure.representation.registerPreset(ViewerAutoPreset);
-            }
-        });
-        return new Viewer(plugin);
-    }
-
-    setRemoteSnapshot(id: string) {
-        const url = `${this.plugin.config.get(PluginConfig.State.CurrentServer)}/get/${id}`;
-        return PluginCommands.State.Snapshots.Fetch(this.plugin, { url });
-    }
-
-    loadSnapshotFromUrl(url: string, type: PluginState.SnapshotType) {
-        return PluginCommands.State.Snapshots.OpenUrl(this.plugin, { url, type });
-    }
-
-    loadStructureFromUrl(url: string, format: BuiltInTrajectoryFormat = 'mmcif', isBinary = false, options?: LoadStructureOptions & { label?: string }) {
-        const params = DownloadStructure.createDefaultParams(this.plugin.state.data.root.obj!, this.plugin);
-        return this.plugin.runTask(this.plugin.state.data.applyAction(DownloadStructure, {
-            source: {
-                name: 'url',
-                params: {
-                    url: Asset.Url(url),
-                    format: format as any,
-                    isBinary,
-                    label: options?.label,
-                    options: { ...params.source.params.options, representationParams: options?.representationParams as any },
-                }
-            }
-        }));
-    }
-
-    async loadAllModelsOrAssemblyFromUrl(url: string, format: BuiltInTrajectoryFormat = 'mmcif', isBinary = false, options?: LoadStructureOptions) {
-        const plugin = this.plugin;
-
-        const data = await plugin.builders.data.download({ url, isBinary }, { state: { isGhost: true } });
-        const trajectory = await plugin.builders.structure.parseTrajectory(data, format);
-
-        await this.plugin.builders.structure.hierarchy.applyPreset(trajectory, 'all-models', { useDefaultIfSingleModel: true, representationPresetParams: options?.representationParams });
-    }
-
-    async loadStructureFromData(data: string | number[], format: BuiltInTrajectoryFormat, options?: { dataLabel?: string }) {
-        const _data = await this.plugin.builders.data.rawData({ data, label: options?.dataLabel });
-        const trajectory = await this.plugin.builders.structure.parseTrajectory(_data, format);
-        await this.plugin.builders.structure.hierarchy.applyPreset(trajectory, 'default');
-    }
-
-    loadPdb(pdb: string, options?: LoadStructureOptions) {
-        const params = DownloadStructure.createDefaultParams(this.plugin.state.data.root.obj!, this.plugin);
-        const provider = this.plugin.config.get(PluginConfig.Download.DefaultPdbProvider)!;
-        return this.plugin.runTask(this.plugin.state.data.applyAction(DownloadStructure, {
-            source: {
-                name: 'pdb' as const,
-                params: {
-                    provider: {
-                        id: pdb,
-                        server: {
-                            name: provider,
-                            params: PdbDownloadProvider[provider].defaultValue as any
-                        }
-                    },
-                    options: { ...params.source.params.options, representationParams: options?.representationParams as any },
-                }
-            }
-        }));
-    }
-
-    loadPdbDev(pdbDev: string) {
-        const params = DownloadStructure.createDefaultParams(this.plugin.state.data.root.obj!, this.plugin);
-        return this.plugin.runTask(this.plugin.state.data.applyAction(DownloadStructure, {
-            source: {
-                name: 'pdb-dev' as const,
-                params: {
-                    provider: {
-                        id: pdbDev,
-                        encoding: 'bcif',
-                    },
-                    options: params.source.params.options,
-                }
-            }
-        }));
-    }
-
-    loadEmdb(emdb: string, options?: { detail?: number }) {
-        const provider = this.plugin.config.get(PluginConfig.Download.DefaultEmdbProvider)!;
-        return this.plugin.runTask(this.plugin.state.data.applyAction(DownloadDensity, {
-            source: {
-                name: 'pdb-emd-ds' as const,
-                params: {
-                    provider: {
-                        id: emdb,
-                        server: provider,
-                    },
-                    detail: options?.detail ?? 3,
-                }
-            }
-        }));
-    }
-
-    loadAlphaFoldDb(afdb: string) {
-        const params = DownloadStructure.createDefaultParams(this.plugin.state.data.root.obj!, this.plugin);
-        return this.plugin.runTask(this.plugin.state.data.applyAction(DownloadStructure, {
-            source: {
-                name: 'alphafolddb' as const,
-                params: {
-                    id: afdb,
-                    options: {
-                        ...params.source.params.options,
-                        representation: 'preset-structure-representation-ma-quality-assessment-plddt'
-                    },
-                }
-            }
-        }));
-    }
-
-    loadModelArchive(id: string) {
-        const params = DownloadStructure.createDefaultParams(this.plugin.state.data.root.obj!, this.plugin);
-        return this.plugin.runTask(this.plugin.state.data.applyAction(DownloadStructure, {
-            source: {
-                name: 'modelarchive' as const,
-                params: {
-                    id,
-                    options: params.source.params.options,
-                }
-            }
-        }));
-    }
-
-    /**
-     * @example Load X-ray density from volume server
-        viewer.loadVolumeFromUrl({
-            url: 'https://www.ebi.ac.uk/pdbe/densities/x-ray/1tqn/cell?detail=3',
-            format: 'dscif',
-            isBinary: true
-        }, [{
-            type: 'relative',
-            value: 1.5,
-            color: 0x3362B2
-        }, {
-            type: 'relative',
-            value: 3,
-            color: 0x33BB33,
-            volumeIndex: 1
-        }, {
-            type: 'relative',
-            value: -3,
-            color: 0xBB3333,
-            volumeIndex: 1
-        }], {
-            entryId: ['2FO-FC', 'FO-FC'],
-            isLazy: true
-        });
-     * *********************
-     * @example Load EM density from volume server
-        viewer.loadVolumeFromUrl({
-            url: 'https://maps.rcsb.org/em/emd-30210/cell?detail=6',
-            format: 'dscif',
-            isBinary: true
-        }, [{
-            type: 'relative',
-            value: 1,
-            color: 0x3377aa
-        }], {
-            entryId: 'EMD-30210',
-            isLazy: true
-        });
-     */
-    async loadVolumeFromUrl({ url, format, isBinary }: { url: string, format: BuildInVolumeFormat, isBinary: boolean }, isovalues: VolumeIsovalueInfo[], options?: { entryId?: string | string[], isLazy?: boolean }) {
-        const plugin = this.plugin;
-
-        if (!plugin.dataFormats.get(format)) {
-            throw new Error(`Unknown density format: ${format}`);
-        }
-
-        if (options?.isLazy) {
-            const update = this.plugin.build();
-            update.toRoot().apply(StateTransforms.Data.LazyVolume, {
-                url,
-                format,
-                entryId: options?.entryId,
-                isBinary,
-                isovalues: isovalues.map(v => ({ alpha: 1, volumeIndex: 0, ...v }))
-            });
-            return update.commit();
-        }
-
-        return plugin.dataTransaction(async () => {
-            const data = await plugin.builders.data.download({ url, isBinary }, { state: { isGhost: true } });
-
-            const parsed = await plugin.dataFormats.get(format)!.parse(plugin, data, { entryId: options?.entryId });
-            const firstVolume = (parsed.volume || parsed.volumes[0]) as StateObjectSelector<PluginStateObject.Volume.Data>;
-            if (!firstVolume?.isOk) throw new Error('Failed to parse any volume.');
-
-            const repr = plugin.build();
-            for (const iso of isovalues) {
-                const volume: StateObjectSelector<PluginStateObject.Volume.Data> = parsed.volumes?.[iso.volumeIndex ?? 0] ?? parsed.volume;
-                const volumeData = volume.cell!.obj!.data;
-                repr
-                    .to(volume)
-                    .apply(StateTransforms.Representation.VolumeRepresentation3D, createVolumeRepresentationParams(this.plugin, firstVolume.data!, {
-                        type: 'isosurface',
-                        typeParams: { alpha: iso.alpha ?? 1, isoValue: Volume.adjustedIsoValue(volumeData, iso.value, iso.type) },
-                        color: 'uniform',
-                        colorParams: { value: iso.color }
-                    }));
-            }
-
-            await repr.commit();
-        });
-    }
-
-    /**
-     * @example
-     *  viewer.loadTrajectory({
-     *      model: { kind: 'model-url', url: 'villin.gro', format: 'gro' },
-     *      coordinates: { kind: 'coordinates-url', url: 'villin.xtc', format: 'xtc', isBinary: true },
-     *      preset: 'all-models' // or 'default'
-     *  });
-     */
-    async loadTrajectory(params: LoadTrajectoryParams) {
-        const plugin = this.plugin;
-
-        let model: StateObjectSelector;
-
-        if (params.model.kind === 'model-data' || params.model.kind === 'model-url') {
-            const data = params.model.kind === 'model-data'
-                ? await plugin.builders.data.rawData({ data: params.model.data, label: params.modelLabel })
-                : await plugin.builders.data.download({ url: params.model.url, isBinary: params.model.isBinary, label: params.modelLabel });
-
-            const trajectory = await plugin.builders.structure.parseTrajectory(data, params.model.format ?? 'mmcif');
-            model = await plugin.builders.structure.createModel(trajectory);
-        } else {
-            const data = params.model.kind === 'topology-data'
-                ? await plugin.builders.data.rawData({ data: params.model.data, label: params.modelLabel })
-                : await plugin.builders.data.download({ url: params.model.url, isBinary: params.model.isBinary, label: params.modelLabel });
-
-            const provider = plugin.dataFormats.get(params.model.format);
-            model = await provider!.parse(plugin, data);
-        }
-
-        const data = params.coordinates.kind === 'coordinates-data'
-            ? await plugin.builders.data.rawData({ data: params.coordinates.data, label: params.coordinatesLabel })
-            : await plugin.builders.data.download({ url: params.coordinates.url, isBinary: params.coordinates.isBinary, label: params.coordinatesLabel });
-
-        const provider = plugin.dataFormats.get(params.coordinates.format);
-        const coords = await provider!.parse(plugin, data);
-
-        const trajectory = await plugin.build().toRoot()
-            .apply(TrajectoryFromModelAndCoordinates, {
-                modelRef: model.ref,
-                coordinatesRef: coords.ref
-            }, { dependsOn: [model.ref, coords.ref] })
-            .commit();
-
-        const preset = await plugin.builders.structure.hierarchy.applyPreset(trajectory, params.preset ?? 'default');
-
-        return { model, coords, preset };
-    }
-
-    handleResize() {
-        this.plugin.layout.events.updated.next(void 0);
-    }
-}
-
-export interface LoadStructureOptions {
-    representationParams?: StructureRepresentationPresetProvider.CommonParams
-}
-
-export interface VolumeIsovalueInfo {
-    type: 'absolute' | 'relative',
-    value: number,
-    color: Color,
-    alpha?: number,
-    volumeIndex?: number
-}
-
-export interface LoadTrajectoryParams {
-    model: { kind: 'model-url', url: string, format?: BuiltInTrajectoryFormat /* mmcif */, isBinary?: boolean }
-    | { kind: 'model-data', data: string | number[] | ArrayBuffer | Uint8Array, format?: BuiltInTrajectoryFormat /* mmcif */ }
-    | { kind: 'topology-url', url: string, format: BuiltInTopologyFormat, isBinary?: boolean }
-    | { kind: 'topology-data', data: string | number[] | ArrayBuffer | Uint8Array, format: BuiltInTopologyFormat },
-    modelLabel?: string,
-    coordinates: { kind: 'coordinates-url', url: string, format: BuiltInCoordinatesFormat, isBinary?: boolean }
-    | { kind: 'coordinates-data', data: string | number[] | ArrayBuffer | Uint8Array, format: BuiltInCoordinatesFormat },
-    coordinatesLabel?: string,
-    preset?: keyof PresetTrajectoryHierarchy
-}
-
-export const ViewerAutoPreset = StructureRepresentationPresetProvider({
-    id: 'preset-structure-representation-viewer-auto',
-    display: {
-        name: 'Automatic (w/ Annotation)', group: 'Annotation',
-        description: 'Show standard automatic representation but colored by quality assessment (if available in the model).'
-    },
-    isApplicable(a) {
-        return (
-            !!a.data.models.some(m => QualityAssessment.isApplicable(m, 'pLDDT')) ||
-            !!a.data.models.some(m => QualityAssessment.isApplicable(m, 'qmean'))
-        );
-    },
-    params: () => StructureRepresentationPresetProvider.CommonParams,
-    async apply(ref, params, plugin) {
-        const structureCell = StateObjectRef.resolveAndCheck(plugin.state.data, ref);
-        const structure = structureCell?.obj?.data;
-        if (!structureCell || !structure) return {};
-
-        if (!!structure.models.some(m => QualityAssessment.isApplicable(m, 'pLDDT'))) {
-            return await QualityAssessmentPLDDTPreset.apply(ref, params, plugin);
-        } else if (!!structure.models.some(m => QualityAssessment.isApplicable(m, 'qmean'))) {
-            return await QualityAssessmentQmeanPreset.apply(ref, params, plugin);
-        } else {
-            return await PresetStructureRepresentations.auto.apply(ref, params, plugin);
-        }
-    }
-});

src/apps/viewer/embedded.html

@@ -1,53 +0,0 @@
-<!DOCTYPE html>
-<html lang="en">
-    <head>
-        <meta charset="utf-8" />
-        <meta name="viewport" content="width=device-width, user-scalable=no, minimum-scale=1.0, maximum-scale=1.0">
-        <link rel="icon" href="./favicon.ico" type="image/x-icon">
-        <title>Embedded Mol* Viewer</title>
-        <style>
-            #app {
-                position: absolute;
-                left: 100px;
-                top: 100px;
-                width: 800px;
-                height: 600px;
-            }
-        </style>
-        <link rel="stylesheet" type="text/css" href="molstar.css" />
-    </head>
-    <body>
-        <div id="app"></div>
-        <script type="text/javascript" src="./molstar.js"></script>
-        <script type="text/javascript">
-            molstar.Viewer.create('app', {
-                layoutIsExpanded: true,
-                layoutShowControls: false,
-                layoutShowRemoteState: false,
-                layoutShowSequence: true,
-                layoutShowLog: false,
-                layoutShowLeftPanel: true,
-
-                viewportShowExpand: true,
-                viewportShowSelectionMode: false,
-                viewportShowAnimation: false,
-
-                pdbProvider: 'rcsb',
-                emdbProvider: 'rcsb',
-            }).then(viewer => {
-                viewer.loadPdb('7bv2');
-                viewer.loadEmdb('EMD-30210', { detail: 6 });
-                // viewer.loadAllModelsOrAssemblyFromUrl('https://cs.litemol.org/5ire/full', 'mmcif', false, { representationParams: { theme: { globalName: 'operator-name' } } })
-                // viewer.loadStructureFromUrl('my url', 'pdb', false, {
-                //     representationParams: {
-                //         theme: {
-                //             globalName: 'uniform',
-                //             globalColorParams: { value: 0xff0000 }
-                //         }
-                //     },
-                //     label: 'my structure'
-                // });
-            });
-        </script>
-    </body>
-</html>

src/apps/viewer/extensions/cellpack/curve.ts

@@ -0,0 +1,228 @@
+/**
+ * Copyright (c) 2019 mol* contributors, licensed under MIT, See LICENSE file for more info.
+ *
+ * @author Ludovic Autin <autin@scripps.edu>
+ * @author Alexander Rose <alexander.rose@weirdbyte.de>
+ */
+
+import { Vec3, Quat, Mat4 } from '../../../../mol-math/linear-algebra';
+import { NumberArray } from '../../../../mol-util/type-helpers';
+
+interface Frame {
+    t: Vec3,
+    r: Vec3,
+    s: Vec3,
+}
+
+const a0Tmp = Vec3()
+const a1Tmp = Vec3()
+const a2Tmp = Vec3()
+const a3Tmp = Vec3()
+function CubicInterpolate(out: Vec3, y0: Vec3, y1: Vec3, y2: Vec3, y3: Vec3, mu: number): Vec3 {
+    const mu2 = mu * mu;
+    Vec3.sub(a0Tmp, y3, y2)
+    Vec3.sub(a0Tmp, a0Tmp, y0)
+    Vec3.add(a0Tmp, a0Tmp, y1)
+
+    Vec3.sub(a1Tmp, y0, y1)
+    Vec3.sub(a1Tmp, a1Tmp, a0Tmp)
+
+    Vec3.sub(a2Tmp, y2, y0)
+
+    Vec3.copy(a3Tmp, y1)
+
+    out[0] = a0Tmp[0] * mu * mu2 + a1Tmp[0] * mu2 + a2Tmp[0] * mu + a3Tmp[0]
+    out[1] = a0Tmp[1] * mu * mu2 + a1Tmp[1] * mu2 + a2Tmp[1] * mu + a3Tmp[1]
+    out[2] = a0Tmp[2] * mu * mu2 + a1Tmp[2] * mu2 + a2Tmp[2] * mu + a3Tmp[2]
+
+    return out
+}
+
+const cp0 = Vec3()
+const cp1 = Vec3()
+const cp2 = Vec3()
+const cp3 = Vec3()
+const currentPosition = Vec3()
+function ResampleControlPoints(points: NumberArray, segmentLength: number) {
+    const nP = points.length / 3
+    // insert a point at the end and at the begining
+    // controlPoints.Insert(0, controlPoints[0] + (controlPoints[0] - controlPoints[1]) / 2.0f);
+    // controlPoints.Add(controlPoints[nP - 1] + (controlPoints[nP - 1] - controlPoints[nP - 2]) / 2.0f);
+
+    let resampledControlPoints: Vec3[] = []
+    // resampledControlPoints.Add(controlPoints[0]);
+    // resampledControlPoints.Add(controlPoints[1]);
+
+    let idx = 1
+    // const currentPosition = Vec3.create(points[idx * 3], points[idx * 3 + 1], points[idx * 3 + 2])
+    Vec3.fromArray(currentPosition, points, idx * 3)
+
+    let lerpValue = 0.0
+
+    // Normalize the distance between control points
+    while (true) {
+        if (idx + 2 >= nP) break
+        Vec3.fromArray(cp0, points, (idx - 1) * 3)
+        Vec3.fromArray(cp1, points, idx * 3)
+        Vec3.fromArray(cp2, points, (idx + 1) * 3)
+        Vec3.fromArray(cp3, points, (idx + 2) * 3)
+        // const cp0 = Vec3.create(points[(idx-1)*3], points[(idx-1)*3+1], points[(idx-1)*3+2]) // controlPoints[currentPointId - 1];
+        // const cp1 = Vec3.create(points[idx*3], points[idx*3+1], points[idx*3+2]) // controlPoints[currentPointId];
+        // const cp2 = Vec3.create(points[(idx+1)*3], points[(idx+1)*3+1], points[(idx+1)*3+2]) // controlPoints[currentPointId + 1];
+        // const cp3 = Vec3.create(points[(idx+2)*3], points[(idx+2)*3+1], points[(idx+2)*3+2]); // controlPoints[currentPointId + 2];
+        let found = false
+        for (; lerpValue <= 1; lerpValue += 0.01) {
+            // lerp?slerp
+            // let candidate:Vec3 = Vec3.lerp(Vec3.zero(), cp0, cp1, lerpValue);
+            // const candidate:Vec3 = Vec3.bezier(Vec3.zero(), cp0, cp1, cp2, cp3, lerpValue);
+            const candidate = CubicInterpolate(Vec3(), cp0, cp1, cp2, cp3, lerpValue)
+            const d = Vec3.distance(currentPosition, candidate);
+            if (d > segmentLength) {
+                resampledControlPoints.push(candidate)
+                Vec3.copy(currentPosition, candidate)
+                found = true
+                break
+            }
+        }
+        if (!found) {
+            lerpValue = 0
+            idx += 1
+        }
+    }
+    return resampledControlPoints
+}
+
+
+const prevV = Vec3()
+const tmpV1 = Vec3()
+const tmpV2 = Vec3()
+const tmpV3 = Vec3()
+
+// easier to align to theses normals
+function GetSmoothNormals(points: Vec3[]) {
+    const nP: number = points.length;
+    const smoothNormals: Vec3[] = []
+    if (points.length < 3) {
+        for (let i = 0; i < points.length; ++i)
+            smoothNormals.push(Vec3.normalize(Vec3(), points[i]))
+        return smoothNormals;
+    }
+    let p0 = points[0]
+    let p1 = points[1]
+    let p2 = points[2]
+    const p21 = Vec3.sub(tmpV1, p2, p1)
+    const p01 =  Vec3.sub(tmpV2, p0, p1)
+    const p0121 = Vec3.cross(tmpV3, p01, p21)
+    Vec3.normalize(prevV, p0121)
+    smoothNormals.push(Vec3.clone(prevV))
+    for (let i = 1; i < points.length - 1; ++i) {
+        p0 = points[i - 1]
+        p1 = points[i]
+        p2 = points[i + 1]
+        const t = Vec3.normalize(tmpV1, Vec3.sub(tmpV1, p2 , p0))
+        const b = Vec3.normalize(tmpV2, Vec3.cross(tmpV2, t, prevV))
+        const n = Vec3.normalize(Vec3(), Vec3.cross(tmpV3, t, b))
+        Vec3.negate(n, n)
+        Vec3.copy(prevV, n)
+        smoothNormals.push(n)
+    }
+    const last = Vec3()
+    Vec3.normalize(last, Vec3.cross(last,
+        Vec3.sub(tmpV1, points[nP - 3], points[nP-2]),
+        Vec3.sub(tmpV2, points[nP-2] , points[nP-1]))
+    )
+    smoothNormals.push(last)
+    return smoothNormals;
+}
+
+const frameTmpV1 = Vec3()
+const frameTmpV2 = Vec3()
+const frameTmpV3 = Vec3()
+
+function getFrame(reference: Vec3, tangent: Vec3) {
+    const t = Vec3.normalize(Vec3(), tangent);
+    // make reference vector orthogonal to tangent
+    const proj_r_to_t = Vec3.scale(
+        frameTmpV1, tangent, Vec3.dot(reference, tangent) / Vec3.dot(tangent, tangent)
+    )
+    const r = Vec3.normalize(Vec3(), Vec3.sub(frameTmpV2, reference, proj_r_to_t))
+    // make bitangent vector orthogonal to the others
+    const s = Vec3.normalize(Vec3(), Vec3.cross(frameTmpV3, t, r))
+    return { t, r, s }
+}
+
+const mfTmpV1 = Vec3()
+const mfTmpV2 = Vec3()
+const mfTmpV3 = Vec3()
+const mfTmpV4 = Vec3()
+const mfTmpV5 = Vec3()
+const mfTmpV6 = Vec3()
+const mfTmpV7 = Vec3()
+const mfTmpV8 = Vec3()
+const mfTmpV9 = Vec3()
+
+// easier to align to theses normals
+// https://github.com/bzamecnik/gpg/blob/master/rotation-minimizing-frame/rmf.py
+function GetMiniFrame(points: Vec3[], normals: Vec3[]) {
+    const frames: Frame[] = [];
+    const t0 = Vec3.normalize(mfTmpV1, Vec3.sub(mfTmpV1, points[1], points[0]))
+    frames.push(getFrame(normals[0], t0))
+
+    for (let i = 0; i< points.length-2; ++i) {
+        const t2 = Vec3.normalize(mfTmpV1, Vec3.sub(mfTmpV1, points[i+2], points[i+1]))
+        const v1 = Vec3.sub(mfTmpV2, points[i + 1], points[i]) // this is tangeant
+        const c1 = Vec3.dot(v1, v1)
+        // compute r_i^L = R_1 * r_i
+        const v1r = Vec3.scale(mfTmpV3, v1, (2.0 / c1) * Vec3.dot(v1, frames[i].r))
+        const ref_L_i = Vec3.sub(mfTmpV4, frames[i].r, v1r)
+        // compute t_i^L = R_1 * t_i
+        const v1t = Vec3.scale(mfTmpV5, v1, (2.0 / c1) * Vec3.dot(v1, frames[i].t))
+        const tan_L_i = Vec3.sub(mfTmpV6, frames[i].t, v1t)
+        // # compute reflection vector of R_2
+        const v2 =  Vec3.sub(mfTmpV7, t2 , tan_L_i)
+        const c2 = Vec3.dot(v2, v2)
+        // compute r_(i+1) = R_2 * r_i^L
+        const v2l = Vec3.scale(mfTmpV8, v1, (2.0/c2) * Vec3.dot(v2, ref_L_i))
+        const ref_next = Vec3.sub(mfTmpV9, ref_L_i, v2l) // ref_L_i - (2 / c2) * v2.dot(ref_L_i) * v2
+        frames.push(getFrame(ref_next, t2)) // frames.append(Frame(ref_next, tangents[i+1]))
+    }
+    return frames;
+}
+
+const rpTmpVec1 = Vec3()
+
+export function getMatFromResamplePoints(points: NumberArray) {
+    const segmentLength = 3.4
+    const new_points = ResampleControlPoints(points, 3.4)
+    const npoints = new_points.length
+    const new_normal = GetSmoothNormals(new_points)
+    const frames = GetMiniFrame(new_points, new_normal)
+    const limit = npoints
+    const transforms: Mat4[] = []
+    const pti = Vec3.copy(rpTmpVec1, new_points[0]);
+    // console.log(new_points.length)
+    // console.log(points.length/3)
+    // console.log(limit)
+    // console.log(segmentLength)
+    for (let i = 0; i<npoints-2; ++i) {
+        const pti1: Vec3 = new_points[i+1] // Vec3.create(points[(i+1)*3],points[(i+1)*3+1],points[(i+1)*3+2]);
+        const d = Vec3.distance(pti, pti1)
+        if (d >= segmentLength) {
+            // use twist or random?
+            const quat = Quat.rotationTo(Quat.zero(), Vec3.create(0, 0, 1), frames[i].t) // Quat.rotationTo(Quat.zero(), Vec3.create(0,0,1),new_normal[i]);//Quat.rotationTo(Quat.zero(), Vec3.create(0,0,1),direction);new_normal
+            const rq = Quat.setAxisAngle(Quat.zero(), frames[i].t, Math.random()*3.60 ) // Quat.setAxisAngle(Quat.zero(),direction, Math.random()*3.60 );//Quat.identity();//
+            const m = Mat4.fromQuat(Mat4.zero(), Quat.multiply(Quat.zero(), rq, quat)) // Mat4.fromQuat(Mat4.zero(),Quat.multiply(Quat.zero(),quat1,quat2));//Mat4.fromQuat(Mat4.zero(),quat);//Mat4.identity();//Mat4.fromQuat(Mat4.zero(),Quat.multiply(Quat.zero(),rq,quat));
+            // let pos:Vec3 = Vec3.add(Vec3.zero(),pti1,pti)
+            // pos = Vec3.scale(pos,pos,1.0/2.0);
+            // Vec3.makeRotation(Mat4.zero(),Vec3.create(0,0,1),frames[i].t);//
+            Mat4.setTranslation(m, pti1)
+            // let m2:Mat4 = GetTubePropertiesMatrix(pti,pti1);
+            // let q:Quat = Quat.rotationTo(Quat.zero(), Vec3.create(0,1,0),Vec3.create(0,0,1))
+            // m2=Mat4.mul(Mat4.identity(),Mat4.fromQuat(Mat4.zero(),q),m2);
+            transforms.push(m)
+            Vec3.copy(pti, pti1)
+        }
+        if (transforms.length >= limit) break
+    }
+    return transforms
+}

src/apps/viewer/extensions/cellpack/data.ts

@@ -0,0 +1,62 @@
+/**
+ * Copyright (c) 2019 mol* contributors, licensed under MIT, See LICENSE file for more info.
+ *
+ * @author Alexander Rose <alexander.rose@weirdbyte.de>
+ */
+
+import { Vec3, Quat } from '../../../../mol-math/linear-algebra';
+
+export interface CellPack {
+    cell: Cell
+    packings: CellPacking[]
+}
+
+export interface CellPacking {
+    name: string,
+    location: 'surface' | 'interior' | 'cytoplasme',
+    ingredients: Packing['ingredients']
+}
+
+//
+
+export interface Cell {
+    recipe: Recipe
+    cytoplasme?: Packing
+    compartments?: { [key: string]: Compartment }
+}
+
+export interface Recipe {
+    setupfile: string
+    /** First entry is name, secound is path: [name: string, path: string][] */
+    paths: [string, string][]
+    version: string
+    name: string
+}
+
+export interface Compartment {
+    surface?: Packing
+    interior?: Packing
+}
+
+export interface Packing {
+    ingredients: { [key: string]: Ingredient }
+}
+
+export interface Ingredient {
+    source: IngredientSource
+    results: [Vec3, Quat][]
+    name: string
+    positions?: [Vec3[]] // why wrapped in an extra array?
+    radii?: [number[]] // why wrapped in an extra array?
+
+    /** Number of `curveX` properties in the object where `X` is a 0-indexed number */
+    nbCurve?: number
+    /** Curve properties are Vec3[] but that is not expressable in TypeScript */
+    [curveX: string]: unknown
+}
+
+export interface IngredientSource {
+    pdb: string
+    transform: { center: boolean, translate?: Vec3 }
+    biomt?: boolean
+}

src/apps/viewer/extensions/cellpack/model.ts

@@ -0,0 +1,474 @@
+/**
+ * Copyright (c) 2019 mol* contributors, licensed under MIT, See LICENSE file for more info.
+ *
+ * @author Alexander Rose <alexander.rose@weirdbyte.de>
+ */
+
+import { StateAction } from '../../../../mol-state';
+import { PluginContext } from '../../../../mol-plugin/context';
+import { PluginStateObject as PSO } from '../../../../mol-plugin/state/objects';
+import { ParamDefinition as PD } from '../../../../mol-util/param-definition';
+import { Ingredient, CellPacking, Cell } from './data';
+import { getFromPdb, getFromCellPackDB } from './util';
+import { Model, Structure, StructureSymmetry, StructureSelection, QueryContext, Unit } from '../../../../mol-model/structure';
+import { trajectoryFromMmCIF } from '../../../../mol-model-formats/structure/mmcif';
+import { trajectoryFromPDB } from '../../../../mol-model-formats/structure/pdb';
+import { Mat4, Vec3, Quat } from '../../../../mol-math/linear-algebra';
+import { SymmetryOperator } from '../../../../mol-math/geometry';
+import { Task } from '../../../../mol-task';
+import { StructureRepresentation3DHelpers } from '../../../../mol-plugin/state/transforms/representation';
+import { StateTransforms } from '../../../../mol-plugin/state/transforms';
+import { distinctColors } from '../../../../mol-util/color/distinct';
+import { ModelIndexColorThemeProvider } from '../../../../mol-theme/color/model-index';
+import { Hcl } from '../../../../mol-util/color/spaces/hcl';
+import { ParseCellPack, StructureFromCellpack, DefaultCellPackBaseUrl } from './state';
+import { MolScriptBuilder as MS } from '../../../../mol-script/language/builder';
+import { getMatFromResamplePoints } from './curve';
+import { compile } from '../../../../mol-script/runtime/query/compiler';
+import { UniformColorThemeProvider } from '../../../../mol-theme/color/uniform';
+import { ThemeRegistryContext } from '../../../../mol-theme/theme';
+import { ColorTheme } from '../../../../mol-theme/color';
+import { _parse_mmCif } from '../../../../mol-model-formats/structure/mmcif/parser';
+import { ModelFormat } from '../../../../mol-model-formats/structure/format';
+import { CifCategory, CifField } from '../../../../mol-io/reader/cif';
+import { mmCIF_Schema } from '../../../../mol-io/reader/cif/schema/mmcif';
+import { Column } from '../../../../mol-data/db';
+
+function getCellPackModelUrl(fileName: string, baseUrl: string) {
+    return `${baseUrl}/results/${fileName}`
+}
+
+async function getModel(id: string, baseUrl: string) {
+    let model: Model;
+    if (id.match(/^[1-9][a-zA-Z0-9]{3,3}$/i)) {
+        // return
+        const cif = await getFromPdb(id)
+        model = (await trajectoryFromMmCIF(cif).run())[0]
+    } else {
+        const pdb = await getFromCellPackDB(id, baseUrl)
+        model = (await trajectoryFromPDB(pdb).run())[0]
+    }
+    return model
+}
+
+async function getStructure(model: Model, props: { assembly?: string } = {}) {
+    let structure = Structure.ofModel(model)
+    const { assembly } = props
+
+    if (assembly) {
+        structure = await StructureSymmetry.buildAssembly(structure, assembly).run()
+    }
+
+    const query = MS.struct.modifier.union([
+        MS.struct.generator.atomGroups({
+            'entity-test': MS.core.rel.eq([MS.ammp('entityType'), 'polymer'])
+        })
+    ])
+    const compiled = compile<StructureSelection>(query)
+    const result = compiled(new QueryContext(structure))
+    structure = StructureSelection.unionStructure(result)
+
+    return structure
+}
+
+function getTransform(trans: Vec3, rot: Quat) {
+    const q: Quat = Quat.create(-rot[3], rot[0], rot[1], rot[2])
+    const m: Mat4 = Mat4.fromQuat(Mat4.zero(), q)
+    Mat4.transpose(m, m)
+    Mat4.scale(m, m, Vec3.create(-1.0, 1.0, -1.0))
+    Mat4.setTranslation(m, trans)
+    return m
+}
+
+function getResultTransforms(results: Ingredient['results']) {
+    return results.map((r: Ingredient['results'][0]) => getTransform(r[0], r[1]))
+}
+
+function getCurveTransforms(ingredient: Ingredient) {
+    const n = ingredient.nbCurve || 0
+    const instances: Mat4[] = []
+
+    for (let i = 0; i < n; ++i) {
+        const cname = `curve${i}`
+        if (!(cname in ingredient)) {
+            // console.warn(`Expected '${cname}' in ingredient`)
+            continue
+        }
+        const _points = ingredient[cname] as Vec3[]
+        if (_points.length <= 2) {
+            // TODO handle curve with 2 or less points
+            continue
+        }
+        const points = new Float32Array(_points.length * 3)
+        for (let i = 0, il = _points.length; i < il; ++i) Vec3.toArray(_points[i], points, i * 3)
+        const newInstances = getMatFromResamplePoints(points)
+        instances.push(...newInstances)
+    }
+
+    return instances
+}
+
+function getAssembly(transforms: Mat4[], structure: Structure) {
+    const builder = Structure.Builder()
+    const { units } = structure;
+
+    for (let i = 0, il = transforms.length; i < il; ++i) {
+        const id = `${i + 1}`
+        const op = SymmetryOperator.create(id, transforms[i], { id, operList: [ id ] })
+        for (const unit of units) {
+            builder.addWithOperator(unit, op)
+        }
+    }
+
+    return builder.getStructure();
+}
+
+function getCifCurve(name: string, transforms: Mat4[], model: Model) {
+    const d = model.sourceData.data.atom_site
+    const n = d._rowCount
+    const rowCount = n * transforms.length
+
+    const { offsets, count } = model.atomicHierarchy.chainAtomSegments
+
+    const x = d.Cartn_x.toArray()
+    const y = d.Cartn_y.toArray()
+    const z = d.Cartn_z.toArray()
+
+    const Cartn_x = new Float32Array(rowCount)
+    const Cartn_y = new Float32Array(rowCount)
+    const Cartn_z = new Float32Array(rowCount)
+    const map = new Uint32Array(rowCount)
+    const seq = new Int32Array(rowCount)
+    let offset = 0
+    for (let c = 0; c < count; ++c) {
+        const cStart = offsets[c]
+        const cEnd = offsets[c + 1]
+        const cLength = cEnd - cStart
+        for (let t = 0, tl = transforms.length; t < tl; ++t) {
+            const m = transforms[t]
+            for (let j = cStart; j < cEnd; ++j) {
+                const i = offset + j - cStart
+                const xj = x[j], yj = y[j], zj = z[j]
+                Cartn_x[i] = m[0] * xj + m[4] * yj + m[8] * zj + m[12]
+                Cartn_y[i] = m[1] * xj + m[5] * yj + m[9] * zj + m[13]
+                Cartn_z[i] = m[2] * xj + m[6] * yj + m[10] * zj + m[14]
+                map[i] = j
+                seq[i] = t + 1
+            }
+            offset += cLength
+        }
+    }
+
+    function multColumn<T>(column: Column<T>) {
+        const array = column.toArray()
+        return Column.ofLambda({
+            value: row => array[map[row]],
+            areValuesEqual: (rowA, rowB) => map[rowA] === map[rowB] || array[map[rowA]] === array[map[rowB]],
+            rowCount, schema: column.schema
+        })
+    }
+
+    const _atom_site: CifCategory.SomeFields<mmCIF_Schema['atom_site']> = {
+        auth_asym_id: CifField.ofColumn(multColumn(d.auth_asym_id)),
+        auth_atom_id: CifField.ofColumn(multColumn(d.auth_atom_id)),
+        auth_comp_id: CifField.ofColumn(multColumn(d.auth_comp_id)),
+        auth_seq_id: CifField.ofNumbers(seq),
+
+        B_iso_or_equiv: CifField.ofColumn(Column.ofConst(0, rowCount, Column.Schema.float)),
+        Cartn_x: CifField.ofNumbers(Cartn_x),
+        Cartn_y: CifField.ofNumbers(Cartn_y),
+        Cartn_z: CifField.ofNumbers(Cartn_z),
+        group_PDB: CifField.ofColumn(Column.ofConst('ATOM', rowCount, Column.Schema.str)),
+        id: CifField.ofColumn(Column.ofLambda({
+            value: row => row,
+            areValuesEqual: (rowA, rowB) => rowA === rowB,
+            rowCount, schema: d.id.schema,
+        })),
+
+        label_alt_id: CifField.ofColumn(multColumn(d.label_alt_id)),
+
+        label_asym_id: CifField.ofColumn(multColumn(d.label_asym_id)),
+        label_atom_id: CifField.ofColumn(multColumn(d.label_atom_id)),
+        label_comp_id: CifField.ofColumn(multColumn(d.label_comp_id)),
+        label_seq_id: CifField.ofNumbers(seq),
+        label_entity_id: CifField.ofColumn(Column.ofConst('1', rowCount, Column.Schema.str)),
+
+        occupancy: CifField.ofColumn(Column.ofConst(1, rowCount, Column.Schema.float)),
+        type_symbol: CifField.ofColumn(multColumn(d.type_symbol)),
+
+        pdbx_PDB_ins_code: CifField.ofColumn(Column.ofConst('', rowCount, Column.Schema.str)),
+        pdbx_PDB_model_num: CifField.ofColumn(Column.ofConst(1, rowCount, Column.Schema.int)),
+    }
+
+    const categories = {
+        entity: CifCategory.ofTable('entity', model.sourceData.data.entity),
+        chem_comp: CifCategory.ofTable('chem_comp', model.sourceData.data.chem_comp),
+        atom_site: CifCategory.ofFields('atom_site', _atom_site)
+    }
+
+    return {
+        header: name,
+        categoryNames: Object.keys(categories),
+        categories
+    };
+}
+
+async function getCurve(name: string, transforms: Mat4[], model: Model) {
+    const cif = getCifCurve(name, transforms, model)
+
+    const curveModelTask = Task.create('Curve Model', async ctx => {
+        const format = ModelFormat.mmCIF(cif)
+        const models = await _parse_mmCif(format, ctx)
+        return models[0]
+    })
+
+    const curveModel = await curveModelTask.run()
+    return getStructure(curveModel)
+}
+
+async function getIngredientStructure(ingredient: Ingredient, baseUrl: string) {
+    const { name, source, results, nbCurve } = ingredient
+
+    // TODO can these be added to the library?
+    if (name === 'HIV1_CAhex_0_1_0') return
+    if (name === 'HIV1_CAhexCyclophilA_0_1_0') return
+    if (name === 'iLDL') return
+    if (name === 'peptides') return
+    if (name === 'lypoglycane') return
+
+    if (source.pdb === 'None') return
+
+    const model = await getModel(source.pdb || name, baseUrl)
+    if (!model) return
+
+    if (nbCurve) {
+        return getCurve(name, getCurveTransforms(ingredient), model)
+    } else {
+        const structure = await getStructure(model, { assembly: source.biomt ? '1' : undefined })
+        return getAssembly(getResultTransforms(results), structure)
+    }
+}
+
+export function createStructureFromCellPack(packing: CellPacking, baseUrl: string) {
+    return Task.create('Create Packing Structure', async ctx => {
+        const { ingredients, name } = packing
+        const structures: Structure[] = []
+        for (const iName in ingredients) {
+            if (ctx.shouldUpdate) await ctx.update(iName)
+            const s = await getIngredientStructure(ingredients[iName], baseUrl)
+            if (s) structures.push(s)
+        }
+
+        if (ctx.shouldUpdate) await ctx.update(`${name} - units`)
+        const builder = Structure.Builder({ label: name })
+        let offsetInvariantId = 0
+        for (const s of structures) {
+            if (ctx.shouldUpdate) await ctx.update(`${s.label}`)
+            let maxInvariantId = 0
+            for (const u of s.units) {
+                const invariantId = u.invariantId + offsetInvariantId
+                if (u.invariantId > maxInvariantId) maxInvariantId = u.invariantId
+                builder.addUnit(u.kind, u.model, u.conformation.operator, u.elements, Unit.Trait.None, invariantId)
+            }
+            offsetInvariantId += maxInvariantId
+        }
+
+        if (ctx.shouldUpdate) await ctx.update(`${name} - structure`)
+        const s = builder.getStructure()
+        return s
+    })
+}
+
+export const LoadCellPackModel = StateAction.build({
+    display: { name: 'Load CellPack Model' },
+    params: {
+        id: PD.Select('influenza_model1.json', [
+            ['blood_hiv_immature_inside.json', 'blood_hiv_immature_inside'],
+            ['BloodHIV1.0_mixed_fixed_nc1.cpr', 'BloodHIV1.0_mixed_fixed_nc1'],
+            ['HIV-1_0.1.6-8_mixed_radii_pdb.cpr', 'HIV-1_0.1.6-8_mixed_radii_pdb'],
+            ['influenza_model1.json', 'influenza_model1'],
+            ['Mycoplasma1.5_mixed_pdb_fixed.cpr', 'Mycoplasma1.5_mixed_pdb_fixed'],
+            ['curveTest', 'Curve Test'],
+        ]),
+        baseUrl: PD.Text(DefaultCellPackBaseUrl),
+        preset: PD.Group({
+            traceOnly: PD.Boolean(false),
+            representation: PD.Select('spacefill', [
+                ['spacefill', 'Spacefill'],
+                ['gaussian-surface', 'Gaussian Surface'],
+                ['point', 'Point'],
+            ] as ['spacefill' | 'gaussian-surface' | 'point', string][])
+        }, { isExpanded: true })
+    },
+    from: PSO.Root
+})(({ state, params }, ctx: PluginContext) => Task.create('CellPack Loader', async taskCtx => {
+    const url = getCellPackModelUrl(params.id, params.baseUrl)
+
+    const root = state.build().toRoot();
+
+    let cellPackBuilder: any
+
+    if (params.id === 'curveTest') {
+        const url = `${params.baseUrl}/extras/rna_allpoints.json`
+        const data = await ctx.fetch({ url, type: 'string' }).runInContext(taskCtx);
+        const { points } = await (new Response(data)).json() as { points: number[] }
+        const curve0: Vec3[] = []
+        for (let j = 0, jl = Math.min(points.length, 3 * 100); j < jl; j += 3) {
+            curve0.push(Vec3.fromArray(Vec3(), points, j))
+        }
+        const cell: Cell = {
+            recipe: { setupfile: '', paths: [], version: '', name: 'Curve Test' },
+            compartments: {
+                'CurveCompartment': {
+                    interior: {
+                        ingredients: {
+                            'CurveIngredient': {
+                                source: { pdb: 'RNA_U_Base.pdb', transform: { center: false } },
+                                results: [],
+                                name: 'RNA',
+                                nbCurve: 1,
+                                curve0
+                            }
+                        }
+                    }
+                }
+            }
+        }
+
+        cellPackBuilder = root
+            .apply(StateTransforms.Data.ImportJson, { data: cell }, { state: { isGhost: true } })
+            .apply(ParseCellPack)
+    } else {
+        cellPackBuilder = root
+            .apply(StateTransforms.Data.Download, { url, isBinary: false, label: params.id }, { state: { isGhost: true } })
+            .apply(StateTransforms.Data.ParseJson, undefined, { state: { isGhost: true } })
+            .apply(ParseCellPack)
+
+
+    }
+
+    const cellPackObject = await state.updateTree(cellPackBuilder).runInContext(taskCtx)
+    const { packings } = cellPackObject.data
+    const tree = state.build().to(cellPackBuilder.ref);
+
+    const isHiv = (
+        params.id === 'BloodHIV1.0_mixed_fixed_nc1.cpr' ||
+        params.id === 'HIV-1_0.1.6-8_mixed_radii_pdb.cpr'
+    )
+
+    if (isHiv) {
+        for (let i = 0, il = packings.length; i < il; ++i) {
+            if (packings[i].name === 'HIV1_capsid_3j3q_PackInner_0_1_0') {
+                const url = `${params.baseUrl}/extras/rna_allpoints.json`
+                const data = await ctx.fetch({ url, type: 'string' }).runInContext(taskCtx);
+                const { points } = await (new Response(data)).json() as { points: number[] }
+
+                const curve0: Vec3[] = []
+                for (let j = 0, jl = points.length; j < jl; j += 3) {
+                    curve0.push(Vec3.fromArray(Vec3(), points, j))
+                }
+                packings[i].ingredients['RNA'] = {
+                    source: { pdb: 'RNA_U_Base.pdb', transform: { center: false } },
+                    results: [],
+                    name: 'RNA',
+                    nbCurve: 1,
+                    curve0
+                }
+            }
+        }
+    }
+
+    const colors = distinctColors(packings.length)
+
+    for (let i = 0, il = packings.length; i < il; ++i) {
+        const hcl = Hcl.fromColor(Hcl(), colors[i])
+        const hue = [Math.max(0, hcl[0] - 35), Math.min(360, hcl[0] + 35)] as [number, number]
+        const p = { packing: i, baseUrl: params.baseUrl }
+
+        let cellpackTree = tree.apply(StructureFromCellpack, p)
+        if (params.preset.traceOnly) {
+            const expression = MS.struct.generator.atomGroups({
+                'atom-test': MS.core.logic.or([
+                    MS.core.rel.eq([MS.ammp('label_atom_id'), 'CA']),
+                    MS.core.rel.eq([MS.ammp('label_atom_id'), 'P'])
+                ])
+            })
+            cellpackTree = cellpackTree.apply(StateTransforms.Model.StructureSelectionFromExpression, { expression }, { state: { isGhost: true } })
+        }
+        cellpackTree
+            .apply(StateTransforms.Representation.StructureRepresentation3D,
+                StructureRepresentation3DHelpers.createParams(ctx, Structure.Empty, {
+                    repr: getReprParams(ctx, params.preset),
+                    color: getColorParams(hue)
+                })
+            )
+    }
+
+    if (isHiv) {
+        const url = `${params.baseUrl}/membranes/hiv_lipids.bcif`
+        tree.apply(StateTransforms.Data.Download, { label: 'hiv_lipids', url, isBinary: true }, { state: { isGhost: true } })
+            .apply(StateTransforms.Data.ParseCif, undefined, { state: { isGhost: true } })
+            .apply(StateTransforms.Model.TrajectoryFromMmCif, undefined, { state: { isGhost: true } })
+            .apply(StateTransforms.Model.ModelFromTrajectory, undefined, { state: { isGhost: true } })
+            .apply(StateTransforms.Model.StructureFromModel, undefined, { state: { isGhost: true } })
+            .apply(StateTransforms.Misc.CreateGroup, { label: 'HIV1_envelope_Membrane' })
+            .apply(StateTransforms.Representation.StructureRepresentation3D,
+                StructureRepresentation3DHelpers.createParams(ctx, Structure.Empty, {
+                    repr: getReprParams(ctx, params.preset),
+                    color: UniformColorThemeProvider
+                })
+            )
+    }
+
+    console.time('cellpack')
+    await state.updateTree(tree).runInContext(taskCtx);
+    console.timeEnd('cellpack')
+}));
+
+function getReprParams(ctx: PluginContext, params: { representation: 'spacefill' | 'gaussian-surface' | 'point', traceOnly: boolean }) {
+    const { representation, traceOnly } = params
+    switch (representation) {
+        case 'spacefill':
+            return traceOnly
+                ? [
+                    ctx.structureRepresentation.registry.get('spacefill'),
+                    () => ({ sizeFactor: 2, ignoreHydrogens: true })
+                ] as [any, any]
+                : [
+                    ctx.structureRepresentation.registry.get('spacefill'),
+                    () => ({ ignoreHydrogens: true })
+                ] as [any, any]
+        case 'gaussian-surface':
+            return [
+                ctx.structureRepresentation.registry.get('gaussian-surface'),
+                () => ({
+                    quality: 'custom', resolution: 10, radiusOffset: 2,
+                    alpha: 1.0, flatShaded: false, doubleSided: false,
+                    ignoreHydrogens: true
+                })
+            ] as [any, any]
+        case 'point':
+            return [
+                ctx.structureRepresentation.registry.get('point'),
+                () => ({ ignoreHydrogens: true })
+            ] as [any, any]
+    }
+}
+
+function getColorParams(hue: [number, number]) {
+    return [
+        ModelIndexColorThemeProvider,
+        (c: ColorTheme.Provider<any>, ctx: ThemeRegistryContext) => {
+            return {
+                palette: {
+                    name: 'generate',
+                    params: {
+                        hue, chroma: [30, 80], luminance: [15, 85],
+                        clusteringStepCount: 50, minSampleCount: 800,
+                        maxCount: 75
+                    }
+                }
+            }
+        }
+    ] as [any, any]
+}

src/apps/viewer/extensions/cellpack/state.ts

@@ -0,0 +1,74 @@
+/**
+ * Copyright (c) 2019 mol* contributors, licensed under MIT, See LICENSE file for more info.
+ *
+ * @author Alexander Rose <alexander.rose@weirdbyte.de>
+ */
+
+import { PluginStateObject as PSO, PluginStateTransform } from '../../../../mol-plugin/state/objects';
+import { ParamDefinition as PD } from '../../../../mol-util/param-definition';
+import { Task } from '../../../../mol-task';
+import { CellPack as _CellPack, Cell, CellPacking } from './data';
+import { createStructureFromCellPack } from './model';
+
+// export const DefaultCellPackBaseUrl = 'https://cdn.jsdelivr.net/gh/mesoscope/cellPACK_data@master/cellPACK_database_1.1.0/'
+export const DefaultCellPackBaseUrl = 'https://mgldev.scripps.edu/projects/autoPACK/web/cellpackproject/'
+
+export class CellPack extends PSO.Create<_CellPack>({ name: 'CellPack', typeClass: 'Object' }) { }
+
+export { ParseCellPack }
+type ParseCellPack = typeof ParseCellPack
+const ParseCellPack = PluginStateTransform.BuiltIn({
+    name: 'parse-cellpack',
+    display: { name: 'Parse CellPack', description: 'Parse CellPack from JSON data' },
+    from: PSO.Format.Json,
+    to: CellPack
+})({
+    apply({ a }) {
+        return Task.create('Parse CellPack', async ctx => {
+            const cell = a.data as Cell
+
+            const packings: CellPacking[] = []
+            const { compartments, cytoplasme } = cell
+            if (compartments) {
+                for (const name in compartments) {
+                    const { surface, interior } = compartments[name]
+                    if (surface) packings.push({ name, location: 'surface', ingredients: surface.ingredients })
+                    if (interior) packings.push({ name, location: 'interior', ingredients: interior.ingredients })
+                }
+            }
+            if (cytoplasme) packings.push({ name: 'Cytoplasme', location: 'cytoplasme', ingredients: cytoplasme.ingredients })
+
+            return new CellPack({ cell, packings });
+        });
+    }
+});
+
+export { StructureFromCellpack }
+type StructureFromCellpack = typeof ParseCellPack
+const StructureFromCellpack = PluginStateTransform.BuiltIn({
+    name: 'structure-from-cellpack',
+    display: { name: 'Structure from CellPack', description: 'Create Structure from CellPack Packing' },
+    from: CellPack,
+    to: PSO.Molecule.Structure,
+    params: a => {
+        if (!a) {
+            return {
+                packing: PD.Numeric(0, {}, { description: 'Packing Index' }),
+                baseUrl: PD.Text(DefaultCellPackBaseUrl)
+            };
+        }
+        const options = a.data.packings.map((d, i) => [i, d.name] as [number, string])
+        return {
+            packing: PD.Select(0, options),
+            baseUrl: PD.Text(DefaultCellPackBaseUrl)
+        }
+    }
+})({
+    apply({ a, params }) {
+        return Task.create('Structure from CellPack', async ctx => {
+            const packing = a.data.packings[params.packing]
+            const structure = await createStructureFromCellPack(packing, params.baseUrl).runInContext(ctx)
+            return new PSO.Molecule.Structure(structure, { label: packing.name })
+        });
+    }
+});

src/apps/viewer/extensions/cellpack/util.ts

@@ -0,0 +1,48 @@
+/**
+ * Copyright (c) 2019 mol* contributors, licensed under MIT, See LICENSE file for more info.
+ *
+ * @author Alexander Rose <alexander.rose@weirdbyte.de>
+ */
+
+import { CIF } from '../../../../mol-io/reader/cif'
+import { parsePDB } from '../../../../mol-io/reader/pdb/parser';
+
+async function parseCif(data: string|Uint8Array) {
+    const comp = CIF.parse(data);
+    const parsed = await comp.run();
+    if (parsed.isError) throw parsed;
+    return parsed.result;
+}
+
+async function parsePDBfile(data: string, id: string) {
+    const comp = parsePDB(data, id);
+    const parsed = await comp.run();
+    if (parsed.isError) throw parsed;
+    return parsed.result;
+}
+
+async function downloadCif(url: string, isBinary: boolean) {
+    const data = await fetch(url);
+    return parseCif(isBinary ? new Uint8Array(await data.arrayBuffer()) : await data.text());
+}
+
+async function downloadPDB(url: string, id: string) {
+    const data = await fetch(url);
+    return parsePDBfile(await data.text(), id);
+}
+
+export async function getFromPdb(id: string) {
+    const parsed = await downloadCif(`https://files.rcsb.org/download/${id}.cif`, false);
+    return parsed.blocks[0];
+}
+
+function getCellPackDataUrl(id: string, baseUrl: string) {
+    const url = `${baseUrl}/other/${id}`
+    return url.endsWith('.pdb') ? url : `${url}.pdb`
+}
+
+export async function getFromCellPackDB(id: string, baseUrl: string) {
+    const name = id.endsWith('.pdb') ? id.substring(0, id.length - 4) : id
+    const parsed = await downloadPDB(getCellPackDataUrl(id, baseUrl), name);
+    return parsed;
+}

src/apps/viewer/extensions/jolecule.ts

@@ -0,0 +1,167 @@
+/**
+ * Copyright (c) 2019 mol* contributors, licensed under MIT, See LICENSE file for more info.
+ *
+ * @author David Sehnal <david.sehnal@gmail.com>
+ */
+
+import { StateTree, StateBuilder, StateAction, State } from '../../../mol-state';
+import { StateTransforms } from '../../../mol-plugin/state/transforms';
+import { createModelTree, complexRepresentation } from '../../../mol-plugin/state/actions/structure';
+import { PluginContext } from '../../../mol-plugin/context';
+import { PluginStateObject } from '../../../mol-plugin/state/objects';
+import { ParamDefinition } from '../../../mol-util/param-definition';
+import { PluginCommands } from '../../../mol-plugin/command';
+import { Vec3 } from '../../../mol-math/linear-algebra';
+import { PluginStateSnapshotManager } from '../../../mol-plugin/state/snapshots';
+import { MolScriptBuilder as MS } from '../../../mol-script/language/builder';
+import { Text } from '../../../mol-geo/geometry/text/text';
+import { UUID } from '../../../mol-util';
+import { ColorNames } from '../../../mol-util/color/names';
+import { Camera } from '../../../mol-canvas3d/camera';
+import { StructureRepresentation3DHelpers } from '../../../mol-plugin/state/transforms/representation';
+
+export const CreateJoleculeState = StateAction.build({
+    display: { name: 'Jolecule State Import' },
+    params: { id: ParamDefinition.Text('1mbo') },
+    from: PluginStateObject.Root
+})(async ({ ref, state, params }, plugin: PluginContext) => {
+    try {
+        const id = params.id.trim().toLowerCase();
+        const data = await plugin.runTask(plugin.fetch({ url: `https://jolecule.appspot.com/pdb/${id}.views.json`, type: 'json' })) as JoleculeSnapshot[];
+
+        data.sort((a, b) => a.order - b.order);
+
+        await PluginCommands.State.RemoveObject.dispatch(plugin, { state, ref });
+        plugin.state.snapshots.clear();
+
+        const template = createTemplate(plugin, state, id);
+        const snapshots = data.map((e, idx) => buildSnapshot(plugin, template, { e, idx, len: data.length }));
+        for (const s of snapshots) {
+            plugin.state.snapshots.add(s);
+        }
+
+        PluginCommands.State.Snapshots.Apply.dispatch(plugin, { id: snapshots[0].snapshot.id });
+    } catch (e) {
+        plugin.log.error(`Jolecule Failed: ${e}`);
+    }
+});
+
+interface JoleculeSnapshot {
+    order: number,
+    distances: { i_atom1: number, i_atom2: number }[],
+    labels: { i_atom: number, text: string }[],
+    camera: { up: Vec3, pos: Vec3, in: Vec3, slab: { z_front: number, z_back: number, zoom: number } },
+    selected: number[],
+    text: string
+}
+
+function createTemplate(plugin: PluginContext, state: State, id: string) {
+    const b = new StateBuilder.Root(state.tree);
+    const data = b.toRoot().apply(StateTransforms.Data.Download, { url: `https://www.ebi.ac.uk/pdbe/static/entry/${id}_updated.cif` }, { state: { isGhost: true }});
+    const model = createModelTree(data, 'cif');
+    const structure = model.apply(StateTransforms.Model.StructureFromModel, {});
+    complexRepresentation(plugin, structure, { hideWater: true });
+    return { tree: b.getTree(), structure: structure.ref };
+}
+
+const labelOptions: ParamDefinition.Values<Text.Params> = {
+    ...ParamDefinition.getDefaultValues(Text.Params),
+    tether: true,
+    sizeFactor: 1.3,
+    attachment: 'bottom-right',
+    offsetZ: 10,
+    background: true,
+    backgroundMargin: 0.2,
+    backgroundColor: ColorNames.skyblue,
+    backgroundOpacity: 0.9
+}
+
+// const distanceLabelOptions = {
+//     ...ParamDefinition.getDefaultValues(Text.Params),
+//     sizeFactor: 1,
+//     offsetX: 0,
+//     offsetY: 0,
+//     offsetZ: 10,
+//     background: true,
+//     backgroundMargin: 0.2,
+//     backgroundColor: ColorNames.snow,
+//     backgroundOpacity: 0.9
+// }
+
+function buildSnapshot(plugin: PluginContext, template: { tree: StateTree, structure: string }, params: { e: JoleculeSnapshot, idx: number, len: number }): PluginStateSnapshotManager.Entry {
+    const b = new StateBuilder.Root(template.tree);
+
+    let i = 0;
+    for (const l of params.e.labels) {
+        const expression = createExpression([l.i_atom]);
+        const group = b.to(template.structure)
+            .group(StateTransforms.Misc.CreateGroup, { label: `Label ${++i}` });
+
+        group
+            .apply(StateTransforms.Model.StructureSelectionFromExpression, { expression, label: 'Atom' })
+            .apply(StateTransforms.Representation.StructureLabels3D, {
+                target: { name: 'static-text', params: { value: l.text || '' } },
+                options: labelOptions
+            });
+
+        group
+            .apply(StateTransforms.Model.StructureSelectionFromExpression, { expression: MS.struct.modifier.wholeResidues([ expression ]), label: 'Residue' })
+            .apply(StateTransforms.Representation.StructureRepresentation3D,
+                StructureRepresentation3DHelpers.getDefaultParamsStatic(plugin, 'ball-and-stick', {  }));
+    }
+    if (params.e.selected && params.e.selected.length > 0) {
+        b.to(template.structure)
+            .apply(StateTransforms.Model.StructureSelectionFromExpression, { expression: createExpression(params.e.selected), label: `Selected` })
+            .apply(StateTransforms.Representation.StructureRepresentation3D,
+                StructureRepresentation3DHelpers.getDefaultParamsStatic(plugin, 'ball-and-stick'));
+    }
+    // TODO
+    // for (const l of params.e.distances) {
+    //     b.to('structure')
+    //         .apply(StateTransforms.Model.StructureSelectionFromExpression, { query: createQuery([l.i_atom1, l.i_atom2]), label: `Distance ${++i}` })
+    //         .apply(StateTransforms.Representation.StructureLabels3D, {
+    //             target: { name: 'static-text', params: { value: l. || '' } },
+    //             options: labelOptions
+    //         });
+    // }
+    return PluginStateSnapshotManager.Entry({
+        id: UUID.create22(),
+        data: { tree: StateTree.toJSON(b.getTree()) },
+        camera: {
+            current: getCameraSnapshot(params.e.camera),
+            transitionStyle: 'animate',
+            transitionDurationInMs: 350
+        }
+    }, {
+        name:  params.e.text
+    });
+}
+
+function getCameraSnapshot(e: JoleculeSnapshot['camera']): Camera.Snapshot {
+    const direction = Vec3.sub(Vec3(), e.pos, e.in);
+    Vec3.normalize(direction, direction);
+    const up = Vec3.sub(Vec3(), e.pos, e.up);
+    Vec3.normalize(up, up);
+
+    const s: Camera.Snapshot = {
+        mode: 'perspective',
+        fov: Math.PI / 4,
+        position: Vec3.scaleAndAdd(Vec3(), e.pos, direction, e.slab.zoom),
+        target: e.pos,
+        radius: (e.slab.z_back - e.slab.z_front) / 2,
+        fog: 50,
+        up,
+    };
+    return s;
+}
+
+function createExpression(atomIndices: number[]) {
+    if (atomIndices.length === 0) return MS.struct.generator.empty();
+
+    return MS.struct.generator.atomGroups({
+        'atom-test': atomIndices.length === 1
+            ? MS.core.rel.eq([MS.struct.atomProperty.core.sourceIndex(), atomIndices[0]])
+            : MS.core.set.has([MS.set.apply(null, atomIndices), MS.struct.atomProperty.core.sourceIndex()]),
+        'group-by': 0
+    });
+}

src/apps/viewer/index.html

@@ -34,81 +34,10 @@
                 height: 600px;
             }
         </style>
-        <link rel="stylesheet" type="text/css" href="molstar.css" />
+        <link rel="stylesheet" type="text/css" href="app.css" />
     </head>
     <body>
         <div id="app"></div>
-        <script type="text/javascript" src="./molstar.js"></script>
-        <script type="text/javascript">
-            function getParam(name, regex) {
-                var r = new RegExp(name + '=' + '(' + regex + ')[&]?', 'i');
-                return decodeURIComponent(((window.location.search || '').match(r) || [])[1] || '');
-            }
-
-            var debugMode = getParam('debug-mode', '[^&]+').trim() === '1';
-            if (debugMode) molstar.setDebugMode(debugMode);
-
-            var timingMode = getParam('timing-mode', '[^&]+').trim() === '1';
-            if (timingMode) molstar.setTimingMode(timingMode);
-
-            var hideControls = getParam('hide-controls', '[^&]+').trim() === '1';
-            var collapseLeftPanel = getParam('collapse-left-panel', '[^&]+').trim() === '1';
-            var pdbProvider = getParam('pdb-provider', '[^&]+').trim().toLowerCase();
-            var emdbProvider = getParam('emdb-provider', '[^&]+').trim().toLowerCase();
-            var mapProvider = getParam('map-provider', '[^&]+').trim().toLowerCase();
-            var pixelScale = getParam('pixel-scale', '[^&]+').trim();
-            var pickScale = getParam('pick-scale', '[^&]+').trim();
-            var pickPadding = getParam('pick-padding', '[^&]+').trim();
-            var disableWboit = getParam('disable-wboit', '[^&]+').trim() === '1';
-            var enableDpoit = getParam('enable-dpoit', '[^&]+').trim() === '1';
-            var preferWebgl1 = getParam('prefer-webgl1', '[^&]+').trim() === '1' || void 0;
-            var allowMajorPerformanceCaveat = getParam('allow-major-performance-caveat', '[^&]+').trim() === '1';
-
-            molstar.Viewer.create('app', {
-                layoutShowControls: !hideControls,
-                viewportShowExpand: false,
-                collapseLeftPanel: collapseLeftPanel,
-                pdbProvider: pdbProvider || 'pdbe',
-                emdbProvider: emdbProvider || 'pdbe',
-                volumeStreamingServer: (mapProvider || 'pdbe') === 'rcsb'
-                    ? 'https://maps.rcsb.org'
-                    : 'https://www.ebi.ac.uk/pdbe/densities',
-                pixelScale: parseFloat(pixelScale) || 1,
-                pickScale: parseFloat(pickScale) || 0.25,
-                pickPadding: isNaN(parseFloat(pickPadding)) ? 1 : parseFloat(pickPadding),
-                enableWboit: (disableWboit || enableDpoit) ? false : void 0, // use default value if disable-wboit is not set
-                enableDpoit: enableDpoit ? true : void 0,
-                preferWebgl1: preferWebgl1,
-                allowMajorPerformanceCaveat: allowMajorPerformanceCaveat,
-            }).then(viewer => {
-                var snapshotId = getParam('snapshot-id', '[^&]+').trim();
-                if (snapshotId) viewer.setRemoteSnapshot(snapshotId);
-
-                var snapshotUrl = getParam('snapshot-url', '[^&]+').trim();
-                var snapshotUrlType = getParam('snapshot-url-type', '[^&]+').toLowerCase().trim() || 'molj';
-                if (snapshotUrl && snapshotUrlType) viewer.loadSnapshotFromUrl(snapshotUrl, snapshotUrlType);
-
-                var structureUrl = getParam('structure-url', '[^&]+').trim();
-                var structureUrlFormat = getParam('structure-url-format', '[a-z]+').toLowerCase().trim();
-                var structureUrlIsBinary = getParam('structure-url-is-binary', '[^&]+').trim() === '1';
-                if (structureUrl) viewer.loadStructureFromUrl(structureUrl, structureUrlFormat, structureUrlIsBinary);
-
-                var pdb = getParam('pdb', '[^&]+').trim();
-                if (pdb) viewer.loadPdb(pdb);
-
-                var pdbDev = getParam('pdb-dev', '[^&]+').trim();
-                if (pdbDev) viewer.loadPdbDev(pdbDev);
-
-                var emdb = getParam('emdb', '[^&]+').trim();
-                if (emdb) viewer.loadEmdb(emdb);
-
-                var afdb = getParam('afdb', '[^&]+').trim();
-                if (afdb) viewer.loadAlphaFoldDb(afdb);
-
-                var modelArchive = getParam('model-archive', '[^&]+').trim();
-                if (modelArchive) viewer.loadModelArchive(modelArchive);
-            });
-        </script>
-        <!-- __MOLSTAR_ANALYTICS__ -->
+        <script type="text/javascript" src="./index.js"></script>
     </body>
 </html>

src/apps/viewer/index.ts

@@ -1,12 +1,67 @@
 /**
- * Copyright (c) 2018-2022 mol* contributors, licensed under MIT, See LICENSE file for more info.
+ * Copyright (c) 2018-2019 mol* contributors, licensed under MIT, See LICENSE file for more info.
  *
  * @author David Sehnal <david.sehnal@gmail.com>
  * @author Alexander Rose <alexander.rose@weirdbyte.de>
  */
 
-import './embedded.html';
-import './favicon.ico';
-import './index.html';
-require('mol-plugin-ui/skin/light.scss');
-export * from './app';
+import { createPlugin, DefaultPluginSpec } from '../../mol-plugin';
+import './index.html'
+import './favicon.ico'
+import { PluginContext } from '../../mol-plugin/context';
+import { PluginCommands } from '../../mol-plugin/command';
+import { PluginSpec } from '../../mol-plugin/spec';
+import { CreateJoleculeState } from './extensions/jolecule';
+import { LoadCellPackModel } from './extensions/cellpack/model';
+import { StructureFromCellpack } from './extensions/cellpack/state';
+require('mol-plugin/skin/light.scss')
+
+function getParam(name: string, regex: string): string {
+    let r = new RegExp(`${name}=(${regex})[&]?`, 'i');
+    return decodeURIComponent(((window.location.search || '').match(r) || [])[1] || '');
+}
+
+const hideControls = getParam('hide-controls', `[^&]+`) === '1';
+
+function init() {
+    const spec: PluginSpec = {
+        actions: [
+            ...DefaultPluginSpec.actions,
+            PluginSpec.Action(CreateJoleculeState),
+            PluginSpec.Action(LoadCellPackModel),
+            PluginSpec.Action(StructureFromCellpack),
+        ],
+        behaviors: [...DefaultPluginSpec.behaviors],
+        animations: [...DefaultPluginSpec.animations || []],
+        customParamEditors: DefaultPluginSpec.customParamEditors,
+        layout: {
+            initial: {
+                isExpanded: true,
+                showControls: !hideControls
+            },
+            controls: {
+                ...DefaultPluginSpec.layout && DefaultPluginSpec.layout.controls
+            }
+        }
+    };
+    const plugin = createPlugin(document.getElementById('app')!, spec);
+    trySetSnapshot(plugin);
+}
+
+async function trySetSnapshot(ctx: PluginContext) {
+    try {
+        const snapshotUrl = getParam('snapshot-url', `[^&]+`);
+        const snapshotId = getParam('snapshot-id', `[^&]+`);
+        if (!snapshotUrl && !snapshotId) return;
+        // TODO parametrize the server
+        const url = snapshotId
+            ? `https://webchem.ncbr.muni.cz/molstar-state/get/${snapshotId}`
+            : snapshotUrl;
+        await PluginCommands.State.Snapshots.Fetch.dispatch(ctx, { url })
+    } catch (e) {
+        ctx.log.error('Failed to load snapshot.');
+        console.warn('Failed to load snapshot', e);
+    }
+}
+
+init();

src/cli/chem-comp-dict/create-ions.ts

@@ -1,79 +0,0 @@
-#!/usr/bin/env node
-/**
- * Copyright (c) 2020-2022 mol* contributors, licensed under MIT, See LICENSE file for more info.
- *
- * @author Josh McMenemy <josh.mcmenemy@gmail.com>
- * @author Alexander Rose <alexander.rose@weirdbyte.de>
- */
-
-import * as argparse from 'argparse';
-import * as path from 'path';
-import util from 'util';
-import fs from 'fs';
-require('util.promisify').shim();
-const writeFile = util.promisify(fs.writeFile);
-
-import { DatabaseCollection } from '../../mol-data/db';
-import { CCD_Schema } from '../../mol-io/reader/cif/schema/ccd';
-import { DefaultDataOptions, ensureDataAvailable, readCCD } from './util';
-
-function extractIonNames(ccd: DatabaseCollection<CCD_Schema>) {
-    const ionNames: string[] = [];
-    for (const k in ccd) {
-        const { chem_comp } = ccd[k];
-        if (chem_comp.name.value(0).toUpperCase().includes(' ION')) {
-            ionNames.push(chem_comp.id.value(0));
-        }
-    }
-    // these are extra ions that don't have ION in their name
-    ionNames.push('NCO', 'OHX');
-    return ionNames;
-}
-
-function writeIonNamesFile(filePath: string, ionNames: string[]) {
-    const output = `/**
- * Copyright (c) 2020-2022 mol* contributors, licensed under MIT, See LICENSE file for more info.
- *
- * Code-generated ion names params file. Names extracted from CCD components.
- *
- * @author molstar/chem-comp-dict/create-ions cli
- */
-
-export const IonNames = new Set(${JSON.stringify(ionNames).replace(/"/g, "'").replace(/,/g, ', ')});
-`;
-    writeFile(filePath, output);
-}
-
-async function run(out: string, options = DefaultDataOptions) {
-    await ensureDataAvailable(options);
-    const ccd = await readCCD();
-    const ionNames = extractIonNames(ccd);
-    if (!fs.existsSync(path.dirname(out))) {
-        fs.mkdirSync(path.dirname(out));
-    }
-    writeIonNamesFile(out, ionNames);
-}
-
-const parser = new argparse.ArgumentParser({
-    add_help: true,
-    description: 'Extract and save IonNames from CCD.'
-});
-parser.add_argument('out', {
-    help: 'Generated file output path.'
-});
-parser.add_argument('--forceDownload', '-f', {
-    action: 'store_true',
-    help: 'Force download of CCD and PVCD.'
-});
-parser.add_argument('--ccdUrl', '-c', {
-    help: 'Fetch the CCD from a custom URL. This forces download of the CCD.',
-    required: false
-});
-interface Args {
-    out: string,
-    forceDownload?: boolean,
-    ccdUrl?: string
-}
-const args: Args = parser.parse_args();
-
-run(args.out, { forceDownload: args.forceDownload, ccdUrl: args.ccdUrl });

src/cli/chem-comp-dict/create-saccharides.ts

@@ -1,82 +0,0 @@
-#!/usr/bin/env node
-/**
- * Copyright (c) 2022 mol* contributors, licensed under MIT, See LICENSE file for more info.
- *
- * @author Alexander Rose <alexander.rose@weirdbyte.de>
- */
-
-import * as argparse from 'argparse';
-import * as path from 'path';
-import util from 'util';
-import fs from 'fs';
-require('util.promisify').shim();
-const writeFile = util.promisify(fs.writeFile);
-
-import { DatabaseCollection } from '../../mol-data/db';
-import { CCD_Schema } from '../../mol-io/reader/cif/schema/ccd';
-import { DefaultDataOptions, ensureDataAvailable, readCCD } from './util';
-
-function extractSaccharideNames(ccd: DatabaseCollection<CCD_Schema>) {
-    const saccharideNames: string[] = [];
-    for (const k in ccd) {
-        const { chem_comp } = ccd[k];
-        const type = chem_comp.type.value(0).toUpperCase();
-        if (type.includes('SACCHARIDE')) {
-            saccharideNames.push(chem_comp.id.value(0));
-        }
-    }
-    // these are extra saccharides that don't have SACCHARIDE in their type
-    saccharideNames.push(
-        'UMQ', // UNDECYL-MALTOSIDE, via GlyFinder
-        'SQD', // SULFOQUINOVOSYLDIACYLGLYCEROL, via GlyFinder
-    );
-    return saccharideNames;
-}
-
-function writeSaccharideNamesFile(filePath: string, ionNames: string[]) {
-    const output = `/**
- * Copyright (c) 2022 mol* contributors, licensed under MIT, See LICENSE file for more info.
- *
- * Code-generated ion names params file. Names extracted from CCD components.
- *
- * @author molstar/cli/chem-comp-dict/create-saccharides
- */
-
-export const SaccharideNames = new Set(${JSON.stringify(ionNames).replace(/"/g, "'").replace(/,/g, ', ')});
-`;
-    writeFile(filePath, output);
-}
-
-async function run(out: string, options = DefaultDataOptions) {
-    await ensureDataAvailable(options);
-    const ccd = await readCCD();
-    const saccharideNames = extractSaccharideNames(ccd);
-    if (!fs.existsSync(path.dirname(out))) {
-        fs.mkdirSync(path.dirname(out));
-    }
-    writeSaccharideNamesFile(out, saccharideNames);
-}
-
-const parser = new argparse.ArgumentParser({
-    add_help: true,
-    description: 'Extract and save SaccharideNames from CCD.'
-});
-parser.add_argument('out', {
-    help: 'Generated file output path.'
-});
-parser.add_argument('--forceDownload', '-f', {
-    action: 'store_true',
-    help: 'Force download of CCD and PVCD.'
-});
-parser.add_argument('--ccdUrl', '-c', {
-    help: 'Fetch the CCD from a custom URL. This forces download of the CCD.',
-    required: false
-});
-interface Args {
-    out: string,
-    forceDownload?: boolean,
-    ccdUrl?: string
-}
-const args: Args = parser.parse_args();
-
-run(args.out, { forceDownload: args.forceDownload, ccdUrl: args.ccdUrl });

src/cli/chem-comp-dict/create-table.ts

@@ -1,304 +0,0 @@
-#!/usr/bin/env node
-/**
- * Copyright (c) 2018-2020 mol* contributors, licensed under MIT, See LICENSE file for more info.
- *
- * @author Alexander Rose <alexander.rose@weirdbyte.de>
- */
-
-import * as argparse from 'argparse';
-import * as util from 'util';
-import * as path from 'path';
-import * as fs from 'fs';
-require('util.promisify').shim();
-const writeFile = util.promisify(fs.writeFile);
-
-import { Database, Table, DatabaseCollection } from '../../mol-data/db';
-import { CCD_Schema } from '../../mol-io/reader/cif/schema/ccd';
-import { SetUtils } from '../../mol-util/set';
-import { DefaultMap } from '../../mol-util/map';
-import { mmCIF_chemCompBond_schema } from '../../mol-io/reader/cif/schema/mmcif-extras';
-import { ccd_chemCompAtom_schema } from '../../mol-io/reader/cif/schema/ccd-extras';
-import { DefaultDataOptions, ensureDataAvailable, getEncodedCif, readCCD, readPVCD } from './util';
-
-type CCB = Table<CCD_Schema['chem_comp_bond']>
-type CCA = Table<CCD_Schema['chem_comp_atom']>
-
-function ccbKey(compId: string, atomId1: string, atomId2: string) {
-    return atomId1 < atomId2 ? `${compId}:${atomId1}-${atomId2}` : `${compId}:${atomId2}-${atomId1}`;
-}
-
-function ccaKey(compId: string, atomId: string) {
-    return `${compId}:${atomId}`;
-}
-
-function addChemCompBondToSet(set: Set<string>, ccb: CCB) {
-    for (let i = 0, il = ccb._rowCount; i < il; ++i) {
-        set.add(ccbKey(ccb.comp_id.value(i), ccb.atom_id_1.value(i), ccb.atom_id_2.value(i)));
-    }
-    return set;
-}
-
-function addChemCompAtomToSet(set: Set<string>, cca: CCA) {
-    for (let i = 0, il = cca._rowCount; i < il; ++i) {
-        set.add(ccaKey(cca.comp_id.value(i), cca.atom_id.value(i)));
-    }
-    return set;
-}
-
-function checkAddingBondsFromPVCD(pvcd: DatabaseCollection<CCD_Schema>) {
-    const ccbSetByParent = DefaultMap<string, Set<string>>(() => new Set());
-
-    for (const k in pvcd) {
-        const { chem_comp, chem_comp_bond } = pvcd[k];
-        if (chem_comp_bond._rowCount) {
-            const parentIds = chem_comp.mon_nstd_parent_comp_id.value(0);
-            if (parentIds.length === 0) {
-                const set = ccbSetByParent.getDefault(chem_comp.id.value(0));
-                addChemCompBondToSet(set, chem_comp_bond);
-            } else {
-                for (let i = 0, il = parentIds.length; i < il; ++i) {
-                    const parentId = parentIds[i];
-                    const set = ccbSetByParent.getDefault(parentId);
-                    addChemCompBondToSet(set, chem_comp_bond);
-                }
-            }
-        }
-    }
-
-    for (const k in pvcd) {
-        const { chem_comp, chem_comp_atom, chem_comp_bond } = pvcd[k];
-        if (chem_comp_bond._rowCount) {
-            const parentIds = chem_comp.mon_nstd_parent_comp_id.value(0);
-            if (parentIds.length > 0) {
-                for (let i = 0, il = parentIds.length; i < il; ++i) {
-                    const entryBonds = addChemCompBondToSet(new Set<string>(), chem_comp_bond);
-                    const entryAtoms = addChemCompAtomToSet(new Set<string>(), chem_comp_atom);
-                    const extraBonds = SetUtils.difference(ccbSetByParent.get(parentIds[i])!, entryBonds);
-                    extraBonds.forEach(bk => {
-                        const [a1, a2] = bk.split('|');
-                        if (entryAtoms.has(a1) && entryAtoms.has(a2)) {
-                            console.error(`Adding all PVCD bonds would wrongly add bond ${bk} for ${k}`);
-                        }
-                    });
-                }
-            }
-        }
-    }
-}
-
-function checkAddingAtomsFromPVCD(pvcd: DatabaseCollection<CCD_Schema>) {
-    const ccaSetByParent = DefaultMap<string, Set<string>>(() => new Set());
-
-    for (const k in pvcd) {
-        const { chem_comp, chem_comp_atom } = pvcd[k];
-        if (chem_comp_atom._rowCount) {
-            const parentIds = chem_comp.mon_nstd_parent_comp_id.value(0);
-            if (parentIds.length === 0) {
-                const set = ccaSetByParent.getDefault(chem_comp.id.value(0));
-                addChemCompAtomToSet(set, chem_comp_atom);
-            } else {
-                for (let i = 0, il = parentIds.length; i < il; ++i) {
-                    const parentId = parentIds[i];
-                    const set = ccaSetByParent.getDefault(parentId);
-                    addChemCompAtomToSet(set, chem_comp_atom);
-                }
-            }
-        }
-    }
-}
-
-async function createBonds(
-    ccd: DatabaseCollection<CCD_Schema>,
-    pvcd: DatabaseCollection<CCD_Schema>,
-    atomsRequested: boolean
-) {
-    const ccbSet = new Set<string>();
-
-    const comp_id: string[] = [];
-    const atom_id_1: string[] = [];
-    const atom_id_2: string[] = [];
-    const value_order: typeof mmCIF_chemCompBond_schema['value_order']['T'][] = [];
-    const pdbx_aromatic_flag: typeof mmCIF_chemCompBond_schema['pdbx_aromatic_flag']['T'][] = [];
-    const pdbx_stereo_config: typeof mmCIF_chemCompBond_schema['pdbx_stereo_config']['T'][] = [];
-    const molstar_protonation_variant: string[] = [];
-
-    function addBonds(compId: string, ccb: CCB, protonationVariant: boolean) {
-        for (let i = 0, il = ccb._rowCount; i < il; ++i) {
-            const atomId1 = ccb.atom_id_1.value(i);
-            const atomId2 = ccb.atom_id_2.value(i);
-            const k = ccbKey(compId, atomId1, atomId2);
-            if (!ccbSet.has(k)) {
-                atom_id_1.push(atomId1);
-                atom_id_2.push(atomId2);
-                comp_id.push(compId);
-                value_order.push(ccb.value_order.value(i));
-                pdbx_aromatic_flag.push(ccb.pdbx_aromatic_flag.value(i));
-                pdbx_stereo_config.push(ccb.pdbx_stereo_config.value(i));
-                molstar_protonation_variant.push(protonationVariant ? 'Y' : 'N');
-                ccbSet.add(k);
-            }
-        }
-    }
-
-    // check adding bonds from PVCD
-    checkAddingBondsFromPVCD(pvcd);
-
-    // add bonds from PVCD
-    for (const k in pvcd) {
-        const { chem_comp, chem_comp_bond } = pvcd[k];
-        if (chem_comp_bond._rowCount) {
-            const parentIds = chem_comp.mon_nstd_parent_comp_id.value(0);
-            if (parentIds.length === 0) {
-                addBonds(chem_comp.id.value(0), chem_comp_bond, false);
-            } else {
-                for (let i = 0, il = parentIds.length; i < il; ++i) {
-                    addBonds(parentIds[i], chem_comp_bond, true);
-                }
-            }
-        }
-    }
-
-    // add bonds from CCD
-    for (const k in ccd) {
-        const { chem_comp, chem_comp_bond } = ccd[k];
-        if (chem_comp_bond._rowCount) {
-            addBonds(chem_comp.id.value(0), chem_comp_bond, false);
-        }
-    }
-
-    const bondTable = Table.ofArrays(mmCIF_chemCompBond_schema, {
-        comp_id, atom_id_1, atom_id_2, value_order,
-        pdbx_aromatic_flag, pdbx_stereo_config, molstar_protonation_variant
-    });
-
-    const bondDatabase = Database.ofTables(
-        CCB_TABLE_NAME,
-        { chem_comp_bond: mmCIF_chemCompBond_schema },
-        { chem_comp_bond: bondTable }
-    );
-
-    return { bonds: bondDatabase, atoms: atomsRequested ? createAtoms(ccd, pvcd) : void 0 };
-}
-
-function createAtoms(ccd: DatabaseCollection<CCD_Schema>, pvcd: DatabaseCollection<CCD_Schema>) {
-    const ccaSet = new Set<string>();
-
-    const comp_id: string[] = [];
-    const atom_id: string[] = [];
-    const charge: number[] = [];
-    const pdbx_stereo_config: typeof CCD_Schema.chem_comp_atom['pdbx_stereo_config']['T'][] = [];
-
-    function addAtoms(compId: string, cca: CCA) {
-        for (let i = 0, il = cca._rowCount; i < il; ++i) {
-            const atomId = cca.atom_id.value(i);
-            const k = ccaKey(compId, atomId);
-            if (!ccaSet.has(k)) {
-                atom_id.push(atomId);
-                comp_id.push(compId);
-                charge.push(cca.charge.value(i));
-                pdbx_stereo_config.push(cca.pdbx_stereo_config.value(i));
-                ccaSet.add(k);
-            }
-        }
-    }
-
-    // check adding atoms from PVCD
-    checkAddingAtomsFromPVCD(pvcd);
-
-    // add atoms from PVCD
-    for (const k in pvcd) {
-        const { chem_comp, chem_comp_atom } = pvcd[k];
-        if (chem_comp_atom._rowCount) {
-            const parentIds = chem_comp.mon_nstd_parent_comp_id.value(0);
-            if (parentIds.length === 0) {
-                addAtoms(chem_comp.id.value(0), chem_comp_atom);
-            } else {
-                for (let i = 0, il = parentIds.length; i < il; ++i) {
-                    addAtoms(parentIds[i], chem_comp_atom);
-                }
-            }
-        }
-    }
-
-    // add atoms from CCD
-    for (const k in ccd) {
-        const { chem_comp, chem_comp_atom } = ccd[k];
-        if (chem_comp_atom._rowCount) {
-            addAtoms(chem_comp.id.value(0), chem_comp_atom);
-        }
-    }
-
-    const atomTable = Table.ofArrays(ccd_chemCompAtom_schema, {
-        comp_id, atom_id, charge, pdbx_stereo_config
-    });
-
-    return Database.ofTables(
-        CCA_TABLE_NAME,
-        { chem_comp_atom: ccd_chemCompAtom_schema },
-        { chem_comp_atom: atomTable }
-    );
-}
-
-async function run(out: string, binary = false, options = DefaultDataOptions, ccaOut?: string) {
-    await ensureDataAvailable(options);
-    const ccd = await readCCD();
-    const pvcd = await readPVCD();
-
-    const { bonds, atoms } = await createBonds(ccd, pvcd, !!ccaOut);
-
-    const ccbCif = getEncodedCif(CCB_TABLE_NAME, bonds, binary);
-    if (!fs.existsSync(path.dirname(out))) {
-        fs.mkdirSync(path.dirname(out));
-    }
-    writeFile(out, ccbCif);
-
-    if (!!ccaOut) {
-        const ccaCif = getEncodedCif(CCA_TABLE_NAME, atoms, binary);
-        if (!fs.existsSync(path.dirname(ccaOut))) {
-            fs.mkdirSync(path.dirname(ccaOut));
-        }
-        writeFile(ccaOut, ccaCif);
-    }
-}
-
-const CCB_TABLE_NAME = 'CHEM_COMP_BONDS';
-const CCA_TABLE_NAME = 'CHEM_COMP_ATOMS';
-
-const parser = new argparse.ArgumentParser({
-    add_help: true,
-    description: 'Create a cif file with one big table of all chem_comp_bond entries from the CCD and PVCD.'
-});
-parser.add_argument('out', {
-    help: 'Generated file output path.'
-});
-parser.add_argument('--forceDownload', '-f', {
-    action: 'store_true',
-    help: 'Force download of CCD and PVCD.'
-});
-parser.add_argument('--binary', '-b', {
-    action: 'store_true',
-    help: 'Output as BinaryCIF.'
-});
-parser.add_argument('--ccaOut', '-a', {
-    help: 'Optional generated file output path for chem_comp_atom data.',
-    required: false
-});
-parser.add_argument('--ccdUrl', '-c', {
-    help: 'Fetch the CCD from a custom URL. This forces download of the CCD.',
-    required: false
-});
-parser.add_argument('--pvcdUrl', '-p', {
-    help: 'Fetch the PVCD from a custom URL. This forces download of the PVCD.',
-    required: false
-});
-interface Args {
-    out: string,
-    forceDownload?: boolean,
-    binary?: boolean,
-    ccaOut?: string,
-    ccdUrl?: string,
-    pvcdUrl?: string
-}
-const args: Args = parser.parse_args();
-
-run(args.out, args.binary, { forceDownload: args.forceDownload, ccdUrl: args.ccdUrl, pvcdUrl: args.pvcdUrl }, args.ccaOut);

src/cli/chem-comp-dict/util.ts

@@ -1,85 +0,0 @@
-/**
- * Copyright (c) 2018-2020 mol* contributors, licensed under MIT, See LICENSE file for more info.
- *
- * @author Alexander Rose <alexander.rose@weirdbyte.de>
- */
-
-import * as util from 'util';
-import * as path from 'path';
-import * as fs from 'fs';
-import * as zlib from 'zlib';
-import fetch from 'node-fetch';
-require('util.promisify').shim();
-const readFile = util.promisify(fs.readFile);
-const writeFile = util.promisify(fs.writeFile);
-
-import { Progress } from '../../mol-task';
-import { Database } from '../../mol-data/db';
-import { CIF } from '../../mol-io/reader/cif';
-import { CifWriter } from '../../mol-io/writer/cif';
-import { CCD_Schema } from '../../mol-io/reader/cif/schema/ccd';
-
-export async function ensureAvailable(path: string, url: string, forceDownload = false) {
-    if (forceDownload || !fs.existsSync(path)) {
-        console.log(`downloading ${url}...`);
-        const data = await fetch(url);
-        if (!fs.existsSync(DATA_DIR)) {
-            fs.mkdirSync(DATA_DIR);
-        }
-        if (url.endsWith('.gz')) {
-            await writeFile(path, zlib.gunzipSync(await data.buffer()));
-        } else {
-            await writeFile(path, await data.text());
-        }
-        console.log(`done downloading ${url}`);
-    }
-}
-
-export async function ensureDataAvailable(options: DataOptions) {
-    await ensureAvailable(CCD_PATH, options.ccdUrl || CCD_URL, !!options.ccdUrl || options.forceDownload);
-    await ensureAvailable(PVCD_PATH, options.pvcdUrl || PVCD_URL, !!options.pvcdUrl || options.forceDownload);
-}
-
-export async function readFileAsCollection<S extends Database.Schema>(path: string, schema: S) {
-    const parsed = await parseCif(await readFile(path, 'utf8'));
-    return CIF.toDatabaseCollection(schema, parsed.result);
-}
-
-export async function readCCD() {
-    return readFileAsCollection(CCD_PATH, CCD_Schema);
-}
-
-export async function readPVCD() {
-    return readFileAsCollection(PVCD_PATH, CCD_Schema);
-}
-
-async function parseCif(data: string | Uint8Array) {
-    const comp = CIF.parse(data);
-    console.time('parse cif');
-    const parsed = await comp.run(p => console.log(Progress.format(p)), 250);
-    console.timeEnd('parse cif');
-    if (parsed.isError) throw parsed;
-    return parsed;
-}
-
-export function getEncodedCif(name: string, database: Database<Database.Schema>, binary = false) {
-    const encoder = CifWriter.createEncoder({ binary, encoderName: 'mol*' });
-    CifWriter.Encoder.writeDatabase(encoder, name, database);
-    return encoder.getData();
-}
-
-export type DataOptions = {
-    ccdUrl?: string,
-    pvcdUrl?: string,
-    forceDownload?: boolean
-}
-
-export const DefaultDataOptions: DataOptions = {
-    forceDownload: false
-};
-
-const DATA_DIR = path.join(__dirname, '..', '..', '..', '..', 'build/data');
-const CCD_PATH = path.join(DATA_DIR, 'components.cif');
-const PVCD_PATH = path.join(DATA_DIR, 'aa-variants-v1.cif');
-const CCD_URL = 'http://ftp.wwpdb.org/pub/pdb/data/monomers/components.cif';
-const PVCD_URL = 'http://ftp.wwpdb.org/pub/pdb/data/monomers/aa-variants-v1.cif';

src/cli/cif2bcif/converter.ts

@@ -1,119 +0,0 @@
-/**
- * Copyright (c) 2017 mol* contributors, licensed under MIT, See LICENSE file for more info.
- *
- * @author David Sehnal <david.sehnal@gmail.com>
- * @author Sebastian Bittrich <sebastian.bittrich@rcsb.org>
- */
-
-import { CIF, CifCategory, getCifFieldType, CifField, CifFile } from '../../mol-io/reader/cif';
-import { CifWriter, EncodingStrategyHint } from '../../mol-io/writer/cif';
-import * as util from 'util';
-import * as fs from 'fs';
-import * as zlib from 'zlib';
-import { Progress, Task, RuntimeContext } from '../../mol-task';
-import { classifyFloatArray, classifyIntArray } from '../../mol-io/common/binary-cif';
-import { BinaryEncodingProvider } from '../../mol-io/writer/cif/encoder/binary';
-import { Category } from '../../mol-io/writer/cif/encoder';
-import { ReaderResult } from '../../mol-io/reader/result';
-
-function showProgress(p: Progress) {
-    process.stdout.write(`\r${new Array(80).join(' ')}`);
-    process.stdout.write(`\r${Progress.format(p)}`);
-}
-
-const readFileAsync = util.promisify(fs.readFile);
-const unzipAsync = util.promisify<zlib.InputType, Buffer>(zlib.unzip);
-
-async function readFile(ctx: RuntimeContext, filename: string): Promise<ReaderResult<CifFile>> {
-    const isGz = /\.gz$/i.test(filename);
-    if (filename.match(/\.bcif/)) {
-        let input = await readFileAsync(filename);
-        if (isGz) input = await unzipAsync(input);
-        return await CIF.parseBinary(new Uint8Array(input)).runInContext(ctx);
-    } else {
-        let str: string;
-        if (isGz) {
-            const data = await unzipAsync(await readFileAsync(filename));
-            str = data.toString('utf8');
-        } else {
-            str = await readFileAsync(filename, 'utf8');
-        }
-        return await CIF.parseText(str).runInContext(ctx);
-    }
-}
-
-async function getCIF(ctx: RuntimeContext, filename: string) {
-    const parsed = await readFile(ctx, filename);
-    if (parsed.isError) {
-        throw new Error(parsed.toString());
-    }
-    return parsed.result;
-}
-
-function getCategoryInstanceProvider(cat: CifCategory, fields: CifWriter.Field[]): CifWriter.Category {
-    return {
-        name: cat.name,
-        instance: () => CifWriter.categoryInstance(fields, { data: cat, rowCount: cat.rowCount })
-    };
-}
-
-function classify(name: string, field: CifField): CifWriter.Field {
-    const type = getCifFieldType(field);
-    if (type['@type'] === 'str') {
-        return { name, type: CifWriter.Field.Type.Str, value: field.str, valueKind: field.valueKind };
-    } else if (type['@type'] === 'float') {
-        const encoder = classifyFloatArray(field.toFloatArray({ array: Float64Array }));
-        return CifWriter.Field.float(name, field.float, { valueKind: field.valueKind, encoder, typedArray: Float64Array });
-    } else {
-        const encoder = classifyIntArray(field.toIntArray({ array: Int32Array }));
-        return CifWriter.Field.int(name, field.int, { valueKind: field.valueKind, encoder, typedArray: Int32Array });
-    }
-}
-
-export function convert(path: string, asText = false, hints?: EncodingStrategyHint[], filter?: string) {
-    return Task.create<Uint8Array>('Convert CIF', async ctx => {
-        const encodingProvider: BinaryEncodingProvider = hints
-            ? CifWriter.createEncodingProviderFromJsonConfig(hints)
-            : { get: (c, f) => void 0 };
-        const cif = await getCIF(ctx, path);
-
-        const encoder = CifWriter.createEncoder({
-            binary: !asText,
-            encoderName: 'mol*/ciftools cif2bcif',
-            binaryAutoClassifyEncoding: true,
-            binaryEncodingPovider: encodingProvider
-        });
-
-        if (filter) {
-            encoder.setFilter(Category.filterOf(filter));
-        }
-
-        let maxProgress = 0;
-        for (const b of cif.blocks) {
-            maxProgress += b.categoryNames.length;
-            for (const c of b.categoryNames) maxProgress += b.categories[c].fieldNames.length;
-        }
-
-        let current = 0;
-        for (const b of cif.blocks) {
-            encoder.startDataBlock(b.header);
-            for (const c of b.categoryNames) {
-                const cat = b.categories[c];
-                const fields: CifWriter.Field[] = [];
-                for (const f of cat.fieldNames) {
-                    fields.push(classify(f, cat.getField(f)!));
-                    current++;
-                    if (ctx.shouldUpdate) await ctx.update({ message: 'Encoding...', current, max: maxProgress });
-                }
-
-                encoder.writeCategory(getCategoryInstanceProvider(b.categories[c], fields));
-                current++;
-                if (ctx.shouldUpdate) await ctx.update({ message: 'Encoding...', current, max: maxProgress });
-            }
-        }
-        await ctx.update('Exporting...');
-        const ret = encoder.getData() as Uint8Array;
-        await ctx.update('Done.\n');
-        return ret;
-    }).run(showProgress, 250);
-}

src/cli/cif2bcif/index.ts

@@ -1,68 +0,0 @@
-#!/usr/bin/env node
-/**
- * Copyright (c) 2017-2019 mol* contributors, licensed under MIT, See LICENSE file for more info.
- *
- * @author David Sehnal <david.sehnal@gmail.com>
- * @author Alexander Rose <alexander.rose@weirdbyte.de>
- */
-
-import * as argparse from 'argparse';
-import * as util from 'util';
-import * as fs from 'fs';
-import * as zlib from 'zlib';
-import { convert } from './converter';
-
-require('util.promisify').shim();
-
-async function process(srcPath: string, outPath: string, configPath?: string, filterPath?: string) {
-    const config = configPath ? JSON.parse(fs.readFileSync(configPath, 'utf8')) : void 0;
-    const filter = filterPath ? fs.readFileSync(filterPath, 'utf8') : void 0;
-
-    const res = await convert(srcPath, srcPath.toLowerCase().indexOf('.bcif') > 0, config, filter);
-    await write(outPath, res);
-}
-
-const zipAsync = util.promisify<zlib.InputType, Buffer>(zlib.gzip);
-
-async function write(outPath: string, res: Uint8Array) {
-    const isGz = /\.gz$/i.test(outPath);
-    if (isGz) {
-        res = await zipAsync(res);
-    }
-    fs.writeFileSync(outPath, res);
-}
-
-function run(args: Args) {
-    process(args.src, args.out, args.config, args.filter);
-}
-
-const parser = new argparse.ArgumentParser({
-    add_help: true,
-    description: 'Convert any BCIF file to a CIF file or vice versa'
-});
-parser.add_argument('src', {
-    help: 'Source file path'
-});
-parser.add_argument('out', {
-    help: 'Output file path'
-});
-parser.add_argument('-c', '--config', {
-    help: 'Optional encoding strategy/precision config path',
-    required: false
-});
-parser.add_argument('-f', '--filter', {
-    help: 'Optional filter whitelist/blacklist path',
-    required: false
-});
-
-interface Args {
-    src: string
-    out: string
-    config?: string
-    filter?: string
-}
-const args: Args = parser.parse_args();
-
-if (args) {
-    run(args);
-}

src/cli/cifschema/index.ts

@@ -1,268 +0,0 @@
-#!/usr/bin/env node
-/**
- * Copyright (c) 2017-2021 mol* contributors, licensed under MIT, See LICENSE file for more info.
- *
- * @author Alexander Rose <alexander.rose@weirdbyte.de>
- */
-
-import * as argparse from 'argparse';
-import * as fs from 'fs';
-import * as path from 'path';
-import fetch from 'node-fetch';
-
-import { parseCsv } from '../../mol-io/reader/csv/parser';
-import { CifFrame, CifBlock } from '../../mol-io/reader/cif';
-import { parseCifText } from '../../mol-io/reader/cif/text/parser';
-import { generateSchema } from './util/cif-dic';
-import { generate } from './util/generate';
-import { Filter, Database } from './util/schema';
-import { parseImportGet } from './util/helper';
-
-function getDicVersion(block: CifBlock) {
-    return block.categories.dictionary.getField('version')!.str(0);
-}
-
-function getDicNamespace(block: CifBlock) {
-    return block.categories.dictionary.getField('namespace')!.str(0);
-}
-
-async function runGenerateSchemaMmcif(name: string, fieldNamesPath: string, typescript = false, out: string, moldbImportPath: string, addAliases: boolean) {
-    await ensureMmcifDicAvailable();
-    const mmcifDic = await parseCifText(fs.readFileSync(MMCIF_DIC_PATH, 'utf8')).run();
-    if (mmcifDic.isError) throw mmcifDic;
-
-    await ensureIhmDicAvailable();
-    const ihmDic = await parseCifText(fs.readFileSync(IHM_DIC_PATH, 'utf8')).run();
-    if (ihmDic.isError) throw ihmDic;
-
-    await ensureMaDicAvailable();
-    const maDic = await parseCifText(fs.readFileSync(MA_DIC_PATH, 'utf8')).run();
-    if (maDic.isError) throw maDic;
-
-    const mmcifDicVersion = getDicVersion(mmcifDic.result.blocks[0]);
-    const ihmDicVersion = getDicVersion(ihmDic.result.blocks[0]);
-    const maDicVersion = getDicVersion(maDic.result.blocks[0]);
-    const version = `Dictionary versions: mmCIF ${mmcifDicVersion}, IHM ${ihmDicVersion}, MA ${maDicVersion}.`;
-
-    const frames: CifFrame[] = [...mmcifDic.result.blocks[0].saveFrames, ...ihmDic.result.blocks[0].saveFrames, ...maDic.result.blocks[0].saveFrames];
-    const schema = generateSchema(frames);
-
-    await runGenerateSchema(name, version, schema, fieldNamesPath, typescript, out, moldbImportPath, addAliases);
-}
-
-async function runGenerateSchemaCifCore(name: string, fieldNamesPath: string, typescript = false, out: string, moldbImportPath: string, addAliases: boolean) {
-    await ensureCifCoreDicAvailable();
-    const cifCoreDic = await parseCifText(fs.readFileSync(CIF_CORE_DIC_PATH, 'utf8')).run();
-    if (cifCoreDic.isError) throw cifCoreDic;
-
-    const cifCoreDicVersion = getDicVersion(cifCoreDic.result.blocks[0]);
-    const version = `Dictionary versions: CifCore ${cifCoreDicVersion}.`;
-
-    const frames: CifFrame[] = [...cifCoreDic.result.blocks[0].saveFrames];
-    const imports = await resolveImports(frames, DIC_DIR);
-    const schema = generateSchema(frames, imports);
-
-    await runGenerateSchema(name, version, schema, fieldNamesPath, typescript, out, moldbImportPath, addAliases);
-}
-
-async function resolveImports(frames: CifFrame[], baseDir: string): Promise<Map<string, CifFrame[]>> {
-    const imports = new Map<string, CifFrame[]>();
-
-    for (const d of frames) {
-        if ('import' in d.categories) {
-            const importGet = parseImportGet(d.categories['import'].getField('get')!.str(0));
-            for (const g of importGet) {
-                const { file } = g;
-                if (!file) continue;
-                if (imports.has(file)) continue;
-
-                const dic = await parseCifText(fs.readFileSync(path.join(baseDir, file), 'utf8')).run();
-                if (dic.isError) throw dic;
-
-                imports.set(file, [...dic.result.blocks[0].saveFrames]);
-            }
-        }
-    }
-
-    return imports;
-}
-
-async function runGenerateSchemaDic(name: string, dicPath: string, fieldNamesPath: string, typescript = false, out: string, moldbImportPath: string, addAliases: boolean) {
-    const dic = await parseCifText(fs.readFileSync(dicPath, 'utf8')).run();
-    if (dic.isError) throw dic;
-
-    const dicVersion = getDicVersion(dic.result.blocks[0]);
-    const dicName = getDicNamespace(dic.result.blocks[0]);
-    const version = `Dictionary versions: ${dicName} ${dicVersion}.`;
-
-    const frames: CifFrame[] = [...dic.result.blocks[0].saveFrames];
-    const imports = await resolveImports(frames, path.dirname(dicPath));
-    const schema = generateSchema(frames, imports);
-
-    await runGenerateSchema(name, version, schema, fieldNamesPath, typescript, out, moldbImportPath, addAliases);
-}
-
-async function runGenerateSchema(name: string, version: string, schema: Database, fieldNamesPath: string, typescript = false, out: string, moldbImportPath: string, addAliases: boolean) {
-    const filter = fieldNamesPath ? await getFieldNamesFilter(fieldNamesPath) : undefined;
-    const output = typescript ? generate(name, version, schema, filter, moldbImportPath, addAliases) : JSON.stringify(schema, undefined, 4);
-
-    if (out) {
-        fs.writeFileSync(out, output);
-    } else {
-        console.log(output);
-    }
-}
-
-async function getFieldNamesFilter(fieldNamesPath: string): Promise<Filter> {
-    const fieldNamesStr = fs.readFileSync(fieldNamesPath, 'utf8');
-    const parsed = await parseCsv(fieldNamesStr, { noColumnNames: true }).run();
-    if (parsed.isError) throw parser.error;
-    const csvFile = parsed.result;
-
-    const fieldNamesCol = csvFile.table.getColumn('0');
-    if (!fieldNamesCol) throw new Error('error getting fields columns');
-    const fieldNames = fieldNamesCol.toStringArray();
-
-    const filter: Filter = {};
-    fieldNames.forEach((name, i) => {
-        const [category, field] = name.split('.');
-        // console.log(category, field)
-        if (!filter[category]) filter[category] = {};
-        filter[category][field] = true;
-    });
-    return filter;
-}
-
-async function ensureMmcifDicAvailable() { await ensureDicAvailable(MMCIF_DIC_PATH, MMCIF_DIC_URL); }
-async function ensureIhmDicAvailable() { await ensureDicAvailable(IHM_DIC_PATH, IHM_DIC_URL); }
-async function ensureMaDicAvailable() { await ensureDicAvailable(MA_DIC_PATH, MA_DIC_URL); }
-async function ensureCifCoreDicAvailable() {
-    await ensureDicAvailable(CIF_CORE_DIC_PATH, CIF_CORE_DIC_URL);
-    await ensureDicAvailable(CIF_CORE_ENUM_PATH, CIF_CORE_ENUM_URL);
-    await ensureDicAvailable(CIF_CORE_ATTR_PATH, CIF_CORE_ATTR_URL);
-}
-
-async function ensureDicAvailable(dicPath: string, dicUrl: string) {
-    if (FORCE_DIC_DOWNLOAD || !fs.existsSync(dicPath)) {
-        const name = dicUrl.substr(dicUrl.lastIndexOf('/') + 1);
-        console.log(`downloading ${name}...`);
-        const data = await fetch(dicUrl);
-        if (!fs.existsSync(DIC_DIR)) {
-            fs.mkdirSync(DIC_DIR);
-        }
-        fs.writeFileSync(dicPath, await data.text());
-        console.log(`done downloading ${name}`);
-    }
-}
-
-const DIC_DIR = path.resolve(__dirname, '../../../../build/dics/');
-const MMCIF_DIC_PATH = `${DIC_DIR}/mmcif_pdbx_v50.dic`;
-const MMCIF_DIC_URL = 'http://mmcif.wwpdb.org/dictionaries/ascii/mmcif_pdbx_v50.dic';
-const IHM_DIC_PATH = `${DIC_DIR}/ihm-extension.dic`;
-const IHM_DIC_URL = 'https://raw.githubusercontent.com/ihmwg/IHM-dictionary/master/ihm-extension.dic';
-const MA_DIC_PATH = `${DIC_DIR}/ma-extension.dic`;
-const MA_DIC_URL = 'https://raw.githubusercontent.com/ihmwg/ModelCIF/master/dist/mmcif_ma.dic';
-
-const CIF_CORE_DIC_PATH = `${DIC_DIR}/cif_core.dic`;
-const CIF_CORE_DIC_URL = 'https://raw.githubusercontent.com/COMCIFS/cif_core/master/cif_core.dic';
-const CIF_CORE_ENUM_PATH = `${DIC_DIR}/templ_enum.cif`;
-const CIF_CORE_ENUM_URL = 'https://raw.githubusercontent.com/COMCIFS/cif_core/master/templ_enum.cif';
-const CIF_CORE_ATTR_PATH = `${DIC_DIR}/templ_attr.cif`;
-const CIF_CORE_ATTR_URL = 'https://raw.githubusercontent.com/COMCIFS/cif_core/master/templ_attr.cif';
-
-const parser = new argparse.ArgumentParser({
-    add_help: true,
-    description: 'Create schema from mmcif dictionary (v50 plus IHM and entity_branch extensions, downloaded from wwPDB)'
-});
-parser.add_argument('--preset', '-p', {
-    default: '',
-    choices: ['', 'mmCIF', 'CCD', 'BIRD', 'CifCore'],
-    help: 'Preset name'
-});
-parser.add_argument('--name', '-n', {
-    default: '',
-    help: 'Schema name'
-});
-parser.add_argument('--out', '-o', {
-    help: 'Generated schema output path, if not given printed to stdout'
-});
-parser.add_argument('--targetFormat', '-tf', {
-    default: 'typescript-molstar',
-    choices: ['typescript-molstar', 'json-internal'],
-    help: 'Target format'
-});
-parser.add_argument('--dicPath', '-d', {
-    default: '',
-    help: 'Path to dictionary'
-});
-parser.add_argument('--fieldNamesPath', '-fn', {
-    default: '',
-    help: 'Field names to include'
-});
-parser.add_argument('--forceDicDownload', '-f', {
-    action: 'store_true',
-    help: 'Force download of dictionaries'
-});
-parser.add_argument('--moldataImportPath', '-mip', {
-    default: 'molstar/lib/mol-data',
-    help: 'mol-data import path (for typescript target only)'
-});
-parser.add_argument('--addAliases', '-aa', {
-    action: 'store_true',
-    help: 'Add field name/path aliases'
-});
-interface Args {
-    name: string
-    preset: '' | 'mmCIF' | 'CCD' | 'BIRD' | 'CifCore'
-    forceDicDownload: boolean
-    dic: '' | 'mmCIF' | 'CifCore'
-    dicPath: string,
-    fieldNamesPath: string
-    targetFormat: 'typescript-molstar' | 'json-internal'
-    out: string,
-    moldataImportPath: string
-    addAliases: boolean
-}
-const args: Args = parser.parse_args();
-
-const FORCE_DIC_DOWNLOAD = args.forceDicDownload;
-
-switch (args.preset) {
-    case 'mmCIF':
-        args.name = 'mmCIF';
-        args.dic = 'mmCIF';
-        args.fieldNamesPath = path.resolve(__dirname, '../../../../data/cif-field-names/mmcif-field-names.csv');
-        break;
-    case 'CCD':
-        args.name = 'CCD';
-        args.dic = 'mmCIF';
-        args.fieldNamesPath = path.resolve(__dirname, '../../../../data/cif-field-names/ccd-field-names.csv');
-        break;
-    case 'BIRD':
-        args.name = 'BIRD';
-        args.dic = 'mmCIF';
-        args.fieldNamesPath = path.resolve(__dirname, '../../../../data/cif-field-names/bird-field-names.csv');
-        break;
-    case 'CifCore':
-        args.name = 'CifCore';
-        args.dic = 'CifCore';
-        args.fieldNamesPath = path.resolve(__dirname, '../../../../data/cif-field-names/cif-core-field-names.csv');
-        break;
-}
-
-if (args.name) {
-    const typescript = args.targetFormat === 'typescript-molstar';
-    if (args.dicPath) {
-        runGenerateSchemaDic(args.name, args.dicPath, args.fieldNamesPath, typescript, args.out, args.moldataImportPath, args.addAliases).catch(e => {
-            console.error(e);
-        });
-    } else if (args.dic === 'mmCIF') {
-        runGenerateSchemaMmcif(args.name, args.fieldNamesPath, typescript, args.out, args.moldataImportPath, args.addAliases).catch(e => {
-            console.error(e);
-        });
-    } else if (args.dic === 'CifCore') {
-        runGenerateSchemaCifCore(args.name, args.fieldNamesPath, typescript, args.out, args.moldataImportPath, args.addAliases).catch(e => {
-            console.error(e);
-        });
-    }
-}

src/cli/cifschema/util/cif-dic.ts

@@ -1,479 +0,0 @@
-/**
- * Copyright (c) 2017-2022 mol* contributors, licensed under MIT, See LICENSE file for more info.
- *
- * @author Alexander Rose <alexander.rose@weirdbyte.de>
- */
-
-import { Database, Column, EnumCol, StrCol, IntCol, ListCol, FloatCol, CoordCol, MatrixCol, VectorCol } from './schema';
-import { parseImportGet } from './helper';
-import * as Data from '../../../mol-io/reader/cif/data-model';
-import { CifFrame } from '../../../mol-io/reader/cif/data-model';
-
-export function getFieldType(type: string, description: string, values?: string[], container?: string): Column {
-    switch (type) {
-        // mmCIF
-        case 'code':
-        case 'line':
-        case 'text':
-        case 'char':
-        case 'boolean':
-            return values && values.length ? EnumCol(values, 'str', description) : StrCol(description);
-        case 'ucode':
-        case 'uline':
-        case 'uchar3':
-        case 'uchar1':
-            // only force lower-case for enums
-            return values && values.length ? EnumCol(values.map(x => x.toLowerCase()), 'lstr', description) : StrCol(description);
-        case 'aliasname':
-        case 'name':
-        case 'idname':
-        case 'any':
-        case 'atcode':
-        case 'fax':
-        case 'phone':
-        case 'email':
-        case 'code30':
-        case 'seq-one-letter-code':
-        case 'author':
-        case 'orcid_id':
-        case 'pdbx_PDB_obsoleted_db_id':
-        case 'pdbx_related_db_id':
-        case 'sequence_dep':
-        case 'pdb_id':
-        case 'emd_id':
-        // todo, consider adding specialised fields
-        case 'yyyy-mm-dd':
-        case 'yyyy-mm-dd:hh:mm':
-        case 'yyyy-mm-dd:hh:mm-flex':
-        case 'int-range':
-        case 'float-range':
-        case 'binary':
-        case 'operation_expression':
-        case 'point_symmetry':
-        case '4x3_matrix':
-        case '3x4_matrix':
-        case '3x4_matrices':
-        case 'point_group':
-        case 'point_group_helical':
-        case 'symmetry_operation':
-        case 'date_dep':
-        case 'url':
-        case 'symop':
-        case 'exp_data_doi':
-        case 'asym_id':
-            return StrCol(description);
-        case 'int':
-        case 'non_negative_int':
-        case 'positive_int':
-            return values && values.length ? EnumCol(values, 'int', description) : IntCol(description);
-        case 'float':
-            return FloatCol(description);
-        case 'ec-type':
-        case 'ucode-alphanum-csv':
-        case 'id_list':
-        case 'entity_id_list':
-            return ListCol('str', ',', description);
-        case 'id_list_spc':
-            return ListCol('str', ' ', description);
-
-        // cif
-        case 'Text':
-        case 'Code':
-        case 'Complex':
-        case 'Symop':
-        case 'List':
-        case 'List(Real,Real)':
-        case 'List(Real,Real,Real,Real)':
-        case 'Date':
-        case 'DateTime':
-        case 'Tag':
-        case 'Implied':
-        case 'Word':
-            return wrapContainer('str', ',', description, container);
-        case 'Real':
-            return wrapContainer('float', ',', description, container);
-        case 'Integer':
-            return wrapContainer('int', ',', description, container);
-
-    }
-    console.log(`unknown type '${type}'`);
-    return StrCol(description);
-}
-
-function ColFromType(type: 'int' | 'str' | 'float' | 'coord', description: string): Column {
-    switch (type) {
-        case 'int': return IntCol(description);
-        case 'str': return StrCol(description);
-        case 'float': return FloatCol(description);
-        case 'coord': return CoordCol(description);
-    }
-}
-
-function wrapContainer(type: 'int' | 'str' | 'float' | 'coord', separator: string, description: string, container?: string) {
-    return container && container === 'List' ? ListCol(type, separator, description) : ColFromType(type, description);
-}
-
-type FrameCategories = { [category: string]: Data.CifFrame }
-type FrameLinks = { [k: string]: string }
-
-interface FrameData {
-    categories: FrameCategories
-    links: FrameLinks
-}
-
-type Imports = Map<string, CifFrame[]>
-
-function getImportFrames(d: Data.CifFrame, imports: Imports) {
-    const frames: Data.CifFrame[] = [];
-    if (!('import' in d.categories)) return frames;
-
-    const importGet = parseImportGet(d.categories['import'].getField('get')!.str(0));
-    for (const g of importGet) {
-        const { file, save } = g;
-        if (!file || !save) {
-            console.warn(`missing 'save' or 'file' for import in '${d.header}'`);
-            continue;
-        }
-        const importFrames = imports.get(file);
-        if (!importFrames) {
-            console.warn(`missing '${file}' entry in imports`);
-            continue;
-        }
-        const importSave = importFrames.find(id => id.header.toLowerCase() === save.toLowerCase());
-        if (!importSave) {
-            console.warn(`missing '${save}' save frame in '${file}'`);
-            continue;
-        }
-
-        frames.push(importSave);
-    }
-
-    return frames;
-}
-
-/** get field from given or linked category */
-function getField(category: string, field: string, d: Data.CifFrame, imports: Imports, ctx: FrameData): Data.CifField|undefined {
-    const { categories, links } = ctx;
-    const cat = d.categories[category];
-    if (cat) {
-        return cat.getField(field);
-    } else if (d.header in links) {
-        const linkName = links[d.header];
-        if (linkName in categories) {
-            return getField(category, field, categories[linkName], imports, ctx);
-        } else {
-            // console.log(`link '${linkName}' not found`)
-        }
-    } else {
-        const importFrames = getImportFrames(d, imports);
-        for (const idf of importFrames) {
-            return getField(category, field, idf, imports, ctx);
-        }
-    }
-}
-
-function getEnums(d: Data.CifFrame, imports: Imports, ctx: FrameData) {
-    const value = getField('item_enumeration', 'value', d, imports, ctx);
-    const enums: string[] = [];
-    if (value) {
-        for (let i = 0; i < value.rowCount; ++i) {
-            enums.push(value.str(i));
-            // console.log(value.str(i))
-        }
-        return enums;
-    } else {
-        // console.log(`item_enumeration.value not found for '${d.header}'`)
-    }
-}
-
-function getContainer(d: Data.CifFrame, imports: Imports, ctx: FrameData) {
-    const value = getField('type', 'container', d, imports, ctx);
-    return value ? value.str(0) : undefined;
-}
-
-function getCode(d: Data.CifFrame, imports: Imports, ctx: FrameData): [string, string[] | undefined, string | undefined ] | undefined {
-    const code = getField('item_type', 'code', d, imports, ctx) || getField('type', 'contents', d, imports, ctx);
-    if (code) {
-        return [code.str(0), getEnums(d, imports, ctx), getContainer(d, imports, ctx)];
-    } else {
-        console.log(`item_type.code or type.contents not found for '${d.header}'`);
-    }
-}
-
-function getSubCategory(d: Data.CifFrame, imports: Imports, ctx: FrameData): string | undefined {
-    const value = getField('item_sub_category', 'id', d, imports, ctx);
-    if (value) {
-        return value.str(0);
-    }
-}
-
-function getDescription(d: Data.CifFrame, imports: Imports, ctx: FrameData): string | undefined {
-    const value = getField('item_description', 'description', d, imports, ctx) || getField('description', 'text', d, imports, ctx);
-    if (value) {
-        // trim (after newlines) and remove references to square brackets
-        return value.str(0).trim()
-            .replace(/(\r\n|\r|\n)([ \t]+)/g, '\n')
-            .replace(/(\[[1-3]\])+ element/, 'elements')
-            .replace(/(\[[1-3]\])+/, '');
-    }
-}
-
-function getAliases(d: Data.CifFrame, imports: Imports, ctx: FrameData): string[] | undefined {
-    const value = getField('item_aliases', 'alias_name', d, imports, ctx) || getField('alias', 'definition_id', d, imports, ctx);
-    return value ? value.toStringArray().map(v => v.substr(1)) : undefined;
-}
-
-const reMatrixField = /\[[1-3]\]\[[1-3]\]/;
-const reVectorField = /\[[1-3]\]/;
-
-const FORCE_INT_FIELDS = [
-    '_atom_site.id',
-    '_atom_site.auth_seq_id',
-    '_atom_site_anisotrop.id',
-    '_pdbx_struct_mod_residue.auth_seq_id',
-    '_struct_conf.beg_auth_seq_id',
-    '_struct_conf.end_auth_seq_id',
-    '_struct_conn.ptnr1_auth_seq_id',
-    '_struct_conn.ptnr2_auth_seq_id',
-    '_struct_sheet_range.beg_auth_seq_id',
-    '_struct_sheet_range.end_auth_seq_id',
-];
-
-/**
- * Note that name and mapped name must share a prefix. This is not always the case in
- * the cifCore dictionary, but for downstream code to work a container field with the
- * same prefix as the member fields must be given here and in the field names filter
- * list.
- */
-const FORCE_MATRIX_FIELDS_MAP: { [k: string]: string } = {
-    'atom_site_aniso.u_11': 'u', // is matrix_u in the the dic
-    'atom_site_aniso.u_22': 'u',
-    'atom_site_aniso.u_33': 'u',
-    'atom_site_aniso.u_23': 'u',
-    'atom_site_aniso.u_13': 'u',
-    'atom_site_aniso.u_12': 'u',
-};
-const FORCE_MATRIX_FIELDS = Object.keys(FORCE_MATRIX_FIELDS_MAP);
-
-const EXTRA_ALIASES: Database['aliases'] = {
-    'atom_site_aniso.matrix_u': [
-        'atom_site_anisotrop_U',
-        'atom_site_aniso.U'
-    ],
-};
-
-const COMMA_SEPARATED_LIST_FIELDS = [
-    '_atom_site.pdbx_struct_group_id',
-    '_chem_comp.mon_nstd_parent_comp_id',
-    '_diffrn_radiation.pdbx_wavelength_list',
-    '_diffrn_source.pdbx_wavelength_list',
-    '_em_diffraction.tilt_angle_list', // 20,40,50,55
-    '_em_entity_assembly.entity_id_list',
-    '_entity.pdbx_description', // Endolysin,Beta-2 adrenergic receptor
-    '_entity.pdbx_ec',
-    '_entity_poly.pdbx_strand_id', // A,B
-    '_entity_src_gen.pdbx_gene_src_gene', // ADRB2, ADRB2R, B2AR
-    '_pdbx_depui_entry_details.experimental_methods',
-    '_pdbx_depui_entry_details.requested_accession_types',
-    '_pdbx_soln_scatter_model.software_list', // INSIGHT II, HOMOLOGY, DISCOVERY, BIOPOLYMER, DELPHI
-    '_pdbx_soln_scatter_model.software_author_list', // MSI
-    '_pdbx_soln_scatter_model.entry_fitting_list', // Odd example: 'PDB CODE 1HFI, 1HCC, 1HFH, 1VCC'
-    '_pdbx_struct_assembly_gen.entity_inst_id',
-    '_pdbx_struct_assembly_gen.asym_id_list',
-    '_pdbx_struct_assembly_gen.auth_asym_id_list',
-    '_pdbx_struct_assembly_gen_depositor_info.asym_id_list',
-    '_pdbx_struct_assembly_gen_depositor_info.chain_id_list',
-    '_pdbx_struct_group_list.group_enumeration_type',
-    '_reflns.pdbx_diffrn_id',
-    '_refine.pdbx_diffrn_id',
-    '_reflns_shell.pdbx_diffrn_id',
-    '_struct_keywords.text',
-];
-
-const SPACE_SEPARATED_LIST_FIELDS = [
-    '_chem_comp.pdbx_subcomponent_list', // TSM DPH HIS CHF EMR
-    '_pdbx_soln_scatter.data_reduction_software_list', // OTOKO
-    '_pdbx_soln_scatter.data_analysis_software_list', // SCTPL5 GNOM
-];
-
-const SEMICOLON_SEPARATED_LIST_FIELDS = [
-    '_chem_comp.pdbx_synonyms' // GLYCERIN; PROPANE-1,2,3-TRIOL
-];
-
-/**
- * Useful when a dictionary extension will add enum values to an existing dictionary.
- * By adding them here, the dictionary extension can be tested before the added enum
- * values are available in the existing dictionary.
- */
-const EXTRA_ENUM_VALUES: { [k: string]: string[] } = {
-
-};
-
-export function generateSchema(frames: CifFrame[], imports: Imports = new Map()): Database {
-    const tables: Database['tables'] = {};
-    const aliases: Database['aliases'] = { ...EXTRA_ALIASES };
-
-    const categories: FrameCategories = {};
-    const links: FrameLinks = {};
-    const ctx = { categories, links };
-
-    // get category metadata
-    frames.forEach(d => {
-        // category definitions in mmCIF start with '_' and don't include a '.'
-        // category definitions in cifCore don't include a '.'
-        if (d.header[0] === '_' || d.header.includes('.')) return;
-        const categoryName = d.header.toLowerCase();
-        // console.log(d.header, d.categoryNames, d.categories)
-        let descriptionField: Data.CifField | undefined;
-        const categoryKeyNames = new Set<string>();
-
-        if ('category' in d.categories && 'category_key' in d.categories) {
-            const category = d.categories['category'];
-            const categoryKey = d.categories['category_key'];
-            if (categoryKey) {
-                const categoryKey_names = categoryKey.getField('name');
-                if (categoryKey_names) {
-                    for (let i = 0, il = categoryKey_names.rowCount; i < il; ++i) {
-                        categoryKeyNames.add(categoryKey_names.str(i));
-                    }
-                }
-            }
-
-            descriptionField = category.getField('description');
-
-            if (categoryKeyNames.size === 0) {
-                console.log(`no key given for category '${categoryName}'`);
-            }
-        }
-
-        if ('description' in d.categories) {
-            descriptionField = d.categories['description'].getField('text');
-        }
-
-        let description = '';
-        if (descriptionField) {
-            description = descriptionField.str(0).trim()
-                .replace(/(\r\n|\r|\n)([ \t]+)/g, '\n'); // remove padding after newlines
-        } else {
-            console.log(`no description given for category '${categoryName}'`);
-        }
-
-        tables[categoryName] = { description, key: categoryKeyNames, columns: {} };
-
-        // console.log('++++++++++++++++++++++++++++++++++++++++++')
-        // console.log('name', categoryName)
-        // console.log('desc', description)
-        // console.log('key', categoryKeyNames)
-    });
-
-    // build list of links between categories
-    frames.forEach(d => {
-        if (d.header[0] !== '_' && !d.header.includes('.')) return;
-        categories[d.header] = d;
-        const item_linked = d.categories['item_linked'];
-        if (item_linked) {
-            const child_name = item_linked.getField('child_name');
-            const parent_name = item_linked.getField('parent_name');
-            if (child_name && parent_name) {
-                for (let i = 0; i < item_linked.rowCount; ++i) {
-                    const childName: string = child_name.str(i);
-                    const parentName = parent_name.str(i);
-                    if (childName in links && links[childName] !== parentName) {
-                        console.log(`${childName} linked to ${links[childName]}, ignoring link to ${parentName}`);
-                    }
-                    links[childName] = parentName;
-                }
-            }
-        }
-    });
-
-    // get field data
-    Object.keys(categories).forEach(fullName => {
-        const d = categories[fullName];
-        if (!d) {
-            console.log(`'${fullName}' not found, moving on`);
-            return;
-        }
-
-        const categoryName = d.header.substring(d.header[0] === '_' ? 1 : 0, d.header.indexOf('.'));
-        const itemName = d.header.substring(d.header.indexOf('.') + 1);
-        let fields: { [k: string]: Column };
-        if (categoryName in tables) {
-            fields = tables[categoryName].columns;
-            tables[categoryName].key.add(itemName);
-        } else if (categoryName.toLowerCase() in tables) {
-            // take case from category name in 'field' data as it is better if data is from cif dictionaries
-            tables[categoryName] = tables[categoryName.toLowerCase()];
-            fields = tables[categoryName].columns;
-        } else {
-            console.log(`category '${categoryName}' has no metadata`);
-            fields = {};
-            tables[categoryName] = {
-                description: '',
-                key: new Set(),
-                columns: fields
-            };
-        }
-
-        const itemAliases = getAliases(d, imports, ctx);
-        if (itemAliases) aliases[`${categoryName}.${itemName}`] = itemAliases;
-
-        const description = getDescription(d, imports, ctx) || '';
-
-        // need to use regex to check for matrix or vector items
-        // as sub_category assignment is missing for some entries
-        const subCategory = getSubCategory(d, imports, ctx);
-        if (subCategory === 'cartesian_coordinate' || subCategory === 'fractional_coordinate') {
-            fields[itemName] = CoordCol(description);
-        } else if (FORCE_INT_FIELDS.includes(d.header)) {
-            fields[itemName] = IntCol(description);
-            console.log(`forcing int: ${d.header}`);
-        } else if (FORCE_MATRIX_FIELDS.includes(d.header)) {
-            fields[itemName] = FloatCol(description);
-            fields[FORCE_MATRIX_FIELDS_MAP[d.header]] = MatrixCol(3, 3, description);
-            console.log(`forcing matrix: ${d.header}`);
-        } else if (subCategory === 'matrix') {
-            fields[itemName.replace(reMatrixField, '')] = MatrixCol(3, 3, description);
-        } else if (subCategory === 'vector') {
-            fields[itemName.replace(reVectorField, '')] = VectorCol(3, description);
-        } else {
-            if (itemName.match(reMatrixField)) {
-                fields[itemName.replace(reMatrixField, '')] = MatrixCol(3, 3, description);
-                console.log(`${d.header} should have 'matrix' _item_sub_category.id`);
-            } else if (itemName.match(reVectorField)) {
-                fields[itemName.replace(reVectorField, '')] = VectorCol(3, description);
-                console.log(`${d.header} should have 'vector' _item_sub_category.id`);
-            } else {
-                const code = getCode(d, imports, ctx);
-                if (code) {
-                    let fieldType = getFieldType(code[0], description, code[1], code[2]);
-                    if (fieldType.type === 'str') {
-                        if (COMMA_SEPARATED_LIST_FIELDS.includes(d.header)) {
-                            fieldType = ListCol('str', ',', description);
-                            console.log(`forcing comma separated: ${d.header}`);
-                        } else if (SPACE_SEPARATED_LIST_FIELDS.includes(d.header)) {
-                            fieldType = ListCol('str', ' ', description);
-                            console.log(`forcing space separated: ${d.header}`);
-                        } else if (SEMICOLON_SEPARATED_LIST_FIELDS.includes(d.header)) {
-                            fieldType = ListCol('str', ';', description);
-                            console.log(`forcing space separated: ${d.header}`);
-                        }
-                    }
-                    if (d.header in EXTRA_ENUM_VALUES) {
-                        if (fieldType.type === 'enum') {
-                            fieldType.values.push(...EXTRA_ENUM_VALUES[d.header]);
-                        } else {
-                            console.warn(`expected enum: ${d.header}`);
-                        }
-                    }
-                    fields[itemName] = fieldType;
-                } else {
-                    fields[itemName] = StrCol(description);
-                    // console.log(`could not determine code for '${d.header}'`)
-                }
-            }
-        }
-    });
-
-    return { tables, aliases };
-}

src/cli/cifschema/util/generate.ts

@@ -1,155 +0,0 @@
-/**
- * Copyright (c) 2017-2022 mol* contributors, licensed under MIT, See LICENSE file for more info.
- *
- * @author Alexander Rose <alexander.rose@weirdbyte.de>
- */
-
-import { Database, Filter, Column } from './schema';
-import { indentString } from '../../../mol-util/string';
-import { FieldPath } from '../../../mol-io/reader/cif/schema';
-
-function header(name: string, info: string, moldataImportPath: string) {
-    return `/**
- * Copyright (c) 2017-2022 mol* contributors, licensed under MIT, See LICENSE file for more info.
- *
- * Code-generated '${name}' schema file. ${info}
- *
- * @author molstar/ciftools package
- */
-
-import { Database, Column } from '${moldataImportPath}/db';
-
-import Schema = Column.Schema;`;
-}
-
-function footer(name: string) {
-    return `
-export type ${name}_Schema = typeof ${name}_Schema;
-export interface ${name}_Database extends Database<${name}_Schema> {};`;
-}
-
-function getTypeShorthands(schema: Database, fields?: Filter) {
-    const types = new Set<string>();
-    Object.keys(schema.tables).forEach(table => {
-        if (fields && !fields[table]) return;
-        const { columns } = schema.tables[table];
-        Object.keys(columns).forEach(columnName => {
-            if (fields && !fields[table][columnName]) return;
-            const col = schema.tables[table].columns[columnName];
-            if (col.type === 'enum') types.add(col.subType);
-            types.add(col.type);
-        });
-    });
-    const shorthands: string[] = [];
-    types.forEach(type => {
-        switch (type) {
-            case 'str': shorthands.push('const str = Schema.str;'); break;
-            case 'ustr': shorthands.push('const ustr = Schema.ustr;'); break;
-            case 'lstr': shorthands.push('const lstr = Schema.lstr;'); break;
-            case 'int': shorthands.push('const int = Schema.int;'); break;
-            case 'float': shorthands.push('const float = Schema.float;'); break;
-            case 'coord': shorthands.push('const coord = Schema.coord;'); break;
-            case 'enum': shorthands.push('const Aliased = Schema.Aliased;'); break;
-            case 'matrix': shorthands.push('const Matrix = Schema.Matrix;'); break;
-            case 'vector': shorthands.push('const Vector = Schema.Vector;'); break;
-            case 'list': shorthands.push('const List = Schema.List;'); break;
-        }
-    });
-    return shorthands.join('\n');
-}
-
-function getTypeDef(c: Column): string {
-    switch (c.type) {
-        case 'str': return 'str';
-        case 'int': return 'int';
-        case 'float': return 'float';
-        case 'coord': return 'coord';
-        case 'enum':
-            return `Aliased<'${c.values.map(v => v.replace(/'/g, '\\\'')).join(`' | '`)}'>(${c.subType})`;
-        case 'matrix':
-            return `Matrix(${c.rows}, ${c.columns})`;
-        case 'vector':
-            return `Vector(${c.length})`;
-        case 'list':
-            if (c.subType === 'int') {
-                return `List('${c.separator}', x => parseInt(x, 10))`;
-            } else if (c.subType === 'float' || c.subType === 'coord') {
-                return `List('${c.separator}', x => parseFloat(x))`;
-            } else {
-                return `List('${c.separator}', x => x)`;
-            }
-    }
-}
-
-const reSafePropertyName = /^[a-zA-Z_$][0-9a-zA-Z_$]*$/;
-function safePropertyString(name: string) { return name.match(reSafePropertyName) ? name : `'${name}'`; }
-
-function doc(description: string, spacesCount: number) {
-    const spaces = ' '.repeat(spacesCount);
-    return [
-        `${spaces}/**`,
-        `${indentString(description, 1, `${spaces} * `)}`.replace(/ +\n/g, '\n'),
-        `${spaces} */`
-    ].join('\n');
-}
-
-export function generate(name: string, info: string, schema: Database, fields: Filter | undefined, moldataImportPath: string, addAliases: boolean) {
-    const codeLines: string[] = [];
-
-    if (fields) {
-        Object.keys(fields).forEach(table => {
-            if (table in schema.tables) {
-                const schemaTable = schema.tables[table];
-                Object.keys(fields[table]).forEach(column => {
-                    if (!(column in schemaTable.columns)) {
-                        console.log(`filter field '${table}.${column}' not found in schema`);
-                    }
-                });
-            } else {
-                console.log(`filter category '${table}' not found in schema`);
-            }
-        });
-    }
-
-    codeLines.push(`export const ${name}_Schema = {`);
-    Object.keys(schema.tables).forEach(table => {
-        if (fields && !fields[table]) return;
-        const { description, columns } = schema.tables[table];
-        if (description) codeLines.push(doc(description, 4));
-        codeLines.push(`    ${safePropertyString(table)}: {`);
-        Object.keys(columns).forEach(columnName => {
-            if (fields && !fields[table][columnName]) return;
-            const c = columns[columnName];
-            const typeDef = getTypeDef(c);
-            if (c.description) codeLines.push(doc(c.description, 8));
-            codeLines.push(`        ${safePropertyString(columnName)}: ${typeDef},`);
-        });
-        codeLines.push('    },');
-    });
-    codeLines.push('};');
-
-    if (addAliases) {
-        codeLines.push('');
-        codeLines.push(`export const ${name}_Aliases = {`);
-        Object.keys(schema.aliases).forEach(path => {
-            const [table, columnName] = path.split('.');
-            if (fields && !fields[table]) return;
-            if (fields && !fields[table][columnName]) return;
-
-            const filteredAliases = new Set<string>();
-            schema.aliases[path].forEach(p => {
-                if (!FieldPath.equal(p, path)) filteredAliases.add(FieldPath.canonical(p));
-            });
-
-            if (filteredAliases.size === 0) return;
-            codeLines.push(`    ${safePropertyString(path)}: [`);
-            filteredAliases.forEach(alias => {
-                codeLines.push(`        '${alias}',`);
-            });
-            codeLines.push('    ],');
-        });
-        codeLines.push('};');
-    }
-
-    return `${header(name, info, moldataImportPath)}\n\n${getTypeShorthands(schema, fields)}\n\n${codeLines.join('\n')}\n${footer(name)}`;
-}

src/cli/cifschema/util/helper.ts

@@ -1,20 +0,0 @@
-/**
- * Copyright (c) 2019 mol* contributors, licensed under MIT, See LICENSE file for more info.
- *
- * @author Alexander Rose <alexander.rose@weirdbyte.de>
- */
-
-export type Import = { save?: string, file?: string }
-
-export function parseImportGet(s: string): Import[] {
-    // [{'save':hi_ang_Fox_coeffs  'file':templ_attr.cif}   {'save':hi_ang_Fox_c0  'file':templ_enum.cif}]
-    // [{"file":'templ_enum.cif' "save":'H_M_ref'}]
-    return s.trim().substring(2, s.length - 2).split(/}[ \n\t]*{/g).map(s => {
-        const save = s.match(/('save'|"save"):([^ \t\n{}]+)/);
-        const file = s.match(/('file'|"file"):([^ \t\n{}]+)/);
-        return {
-            save: save ? save[0].substr(7).replace(/['"]/g, '') : undefined,
-            file: file ? file[0].substr(7).replace(/['"]/g, '') : undefined
-        };
-    });
-}

src/cli/cifschema/util/schema.ts

@@ -1,77 +0,0 @@
-/**
- * Copyright (c) 2017-2022 mol* contributors, licensed under MIT, See LICENSE file for more info.
- *
- * @author Alexander Rose <alexander.rose@weirdbyte.de>
- */
-
-export interface Database {
-    tables: { [ tableName: string ]: Table }
-    aliases: { [ path: string ]: string[] }
-}
-export interface Table {
-    description: string
-    key: Set<string>
-    columns: { [ columnName: string ]: Column }
-}
-export type Column = IntCol | StrCol | FloatCol | CoordCol | EnumCol | VectorCol | MatrixCol | ListCol
-
-type BaseCol = { description: string }
-
-export type IntCol = { type: 'int' } & BaseCol
-export function IntCol(description: string): IntCol { return { type: 'int', description }; }
-
-export type StrCol = { type: 'str' } & BaseCol
-export function StrCol(description: string): StrCol { return { type: 'str', description }; }
-
-export type FloatCol = { type: 'float' } & BaseCol
-export function FloatCol(description: string): FloatCol { return { type: 'float', description }; }
-
-export type CoordCol = { type: 'coord' } & BaseCol
-export function CoordCol(description: string): CoordCol { return { type: 'coord', description }; }
-
-export type EnumCol = { type: 'enum', subType: 'int' | 'str' | 'ustr' | 'lstr', values: string[] } & BaseCol
-export function EnumCol(values: string[], subType: 'int' | 'str' | 'ustr' | 'lstr', description: string): EnumCol {
-    return { type: 'enum', description, values, subType };
-}
-
-export type VectorCol = { type: 'vector', length: number } & BaseCol
-export function VectorCol(length: number, description: string): VectorCol {
-    return { type: 'vector', description, length };
-}
-
-export type MatrixCol = { type: 'matrix', rows: number, columns: number } & BaseCol
-export function MatrixCol(columns: number, rows: number, description: string): MatrixCol {
-    return { type: 'matrix', description, columns, rows };
-}
-
-export type ListCol = { type: 'list', subType: 'int' | 'str' | 'float' | 'coord', separator: string } & BaseCol
-export function ListCol(subType: 'int' | 'str' | 'float' | 'coord', separator: string, description: string): ListCol {
-    return { type: 'list', description, separator, subType };
-}
-
-export type Filter = { [ table: string ]: { [ column: string ]: true } }
-
-export function mergeFilters(...filters: Filter[]) {
-    const n = filters.length;
-    const mergedFilter: Filter = {};
-    const fields: Map<string, number> = new Map();
-    filters.forEach(filter => {
-        Object.keys(filter).forEach(category => {
-            Object.keys(filter[category]).forEach(field => {
-                const key = `${category}.${field}`;
-                const value = fields.get(key) || 0;
-                fields.set(key, value + 1);
-            });
-        });
-    });
-    fields.forEach((v, k) => {
-        if (v !== n) return;
-        const [categoryName, fieldName] = k.split('.');
-        if (categoryName in mergedFilter) {
-            mergedFilter[categoryName][fieldName] = true;
-        } else {
-            mergedFilter[categoryName] = { fieldName: true };
-        }
-    });
-    return mergedFilter;
-}

src/cli/lipid-params/index.ts

@@ -1,93 +0,0 @@
-#!/usr/bin/env node
-/**
- * Copyright (c) 2020 mol* contributors, licensed under MIT, See LICENSE file for more info.
- *
- * @author Alexander Rose <alexander.rose@weirdbyte.de>
- */
-
-import * as argparse from 'argparse';
-import * as fs from 'fs';
-import * as path from 'path';
-import fetch from 'node-fetch';
-import { UniqueArray } from '../../mol-data/generic';
-
-const LIPIDS_DIR = path.resolve(__dirname, '../../../../build/lipids/');
-
-const MARTINI_LIPIDS_PATH = path.resolve(LIPIDS_DIR, 'martini_lipids.itp');
-const MARTINI_LIPIDS_URL = 'http://www.cgmartini.nl/images/parameters/lipids/Collections/martini_v2.0_lipids_all_201506.itp';
-
-async function ensureAvailable(path: string, url: string) {
-    if (FORCE_DOWNLOAD || !fs.existsSync(path)) {
-        const name = url.substr(url.lastIndexOf('/') + 1);
-        console.log(`downloading ${name}...`);
-        const data = await fetch(url);
-        if (!fs.existsSync(LIPIDS_DIR)) {
-            fs.mkdirSync(LIPIDS_DIR);
-        }
-        fs.writeFileSync(path, await data.text());
-        console.log(`done downloading ${name}`);
-    }
-}
-
-async function ensureLipidsAvailable() { await ensureAvailable(MARTINI_LIPIDS_PATH, MARTINI_LIPIDS_URL); }
-
-const extraLipids = ['DMPC'];
-
-async function run(out: string) {
-    await ensureLipidsAvailable();
-    const lipidsItpStr = fs.readFileSync(MARTINI_LIPIDS_PATH, 'utf8');
-
-    const lipids = UniqueArray.create<string>();
-    const reLipid = /\[moleculetype\]\n; molname      nrexcl\n +([a-zA-Z]{3,5})/g;
-    let m: RegExpExecArray | null;
-
-    while ((m = reLipid.exec(lipidsItpStr)) !== null) {
-        const v = m[0].substr(m[0].lastIndexOf(' ') + 1);
-        UniqueArray.add(lipids, v, v);
-    }
-
-    for (const v of extraLipids) {
-        UniqueArray.add(lipids, v, v);
-    }
-
-    const lipidNames = JSON.stringify(lipids.array);
-
-    if (out) {
-        const output = `/**
- * Copyright (c) 2020 mol* contributors, licensed under MIT, See LICENSE file for more info.
- *
- * Code-generated lipid params file. Names extracted from Martini FF lipids itp.
- *
- * @author molstar/lipid-params cli
- */
-
-export const LipidNames = new Set(${lipidNames.replace(/"/g, "'").replace(/,/g, ', ')});
-`;
-        fs.writeFileSync(out, output);
-    } else {
-        console.log(lipidNames);
-    }
-}
-
-const parser = new argparse.ArgumentParser({
-    add_help: true,
-    description: 'Create lipid params (from martini lipids itp)'
-});
-parser.add_argument('--out', '-o', {
-    help: 'Generated lipid params output path, if not given printed to stdout'
-});
-parser.add_argument('--forceDownload', '-f', {
-    action: 'store_true',
-    help: 'Force download of martini lipids itp'
-});
-interface Args {
-    out: string
-    forceDownload: boolean
-}
-const args: Args = parser.parse_args();
-
-const FORCE_DOWNLOAD = args.forceDownload;
-
-run(args.out || '').catch(e => {
-    console.error(e);
-});

src/examples/alpha-orbitals/controls.tsx

@@ -1,24 +0,0 @@
-/**
- * Copyright (c) 2020 mol* contributors, licensed under MIT, See LICENSE file for more info.
- *
- * @author David Sehnal <david.sehnal@gmail.com>
- */
-
-import { createRoot } from 'react-dom/client';
-import { AlphaOrbitalsExample } from '.';
-import { ParameterControls } from '../../mol-plugin-ui/controls/parameters';
-import { useBehavior } from '../../mol-plugin-ui/hooks/use-behavior';
-import { PluginContextContainer } from '../../mol-plugin-ui/plugin';
-
-export function mountControls(orbitals: AlphaOrbitalsExample, parent: Element) {
-    createRoot(parent).render(<PluginContextContainer plugin={orbitals.plugin}>
-        <Controls orbitals={orbitals} />
-    </PluginContextContainer>);
-}
-
-function Controls({ orbitals }: { orbitals: AlphaOrbitalsExample }) {
-    const params = useBehavior(orbitals.params);
-    const values = useBehavior(orbitals.state);
-
-    return <ParameterControls params={params as any} values={values} onChangeValues={(vs: any) => orbitals.state.next(vs)} />;
-}

src/examples/alpha-orbitals/index.html

@@ -1,73 +0,0 @@
-<!DOCTYPE html>
-<html lang="en">
-    <head>
-        <meta charset="utf-8" />
-        <meta name="viewport" content="width=device-width, user-scalable=no, minimum-scale=1.0, maximum-scale=1.0">
-        <title>Mol* Alpha Orbitals Example</title>
-        <style>
-            * {
-                margin: 0;
-                padding: 0;
-                box-sizing: border-box;
-            }
-            #app {
-                position: absolute;
-                left: 0;
-                top: 0;
-                bottom: 0;
-                right: 0;
-            }
-            #controls {
-                position: absolute;
-                left: 8px;
-                top: 8px;
-                width: 300px;
-            }
-            #sponsor {
-                position: absolute;
-                left: 8px;
-                bottom: 8px;
-                font-family: "Helvetica Neue", "Segoe UI", Helvetica, "Source Sans Pro", Arial, sans-serif;
-                font-size: 12px;
-                text-align: center;
-            }
-            #sponsor svg {
-                fill: #128EA4;
-                width: 100px;
-            }
-            #sponsor a {
-                text-decoration: none;
-                color: #128EA4;
-            }
-        </style>
-        <link rel="stylesheet" type="text/css" href="molstar.css" />
-        <script type="text/javascript" src="./index.js"></script>
-    </head>
-    <body>
-        <div id="app"></div>
-        <div id='controls'></div>
-        <div id='sponsor'>
-            <a href='https://www.entos.ai/envision' target="_blank" rel="noopener">
-                <svg class="makeStyles-root-46" viewBox="0 0 190 36" xmlns="http://www.w3.org/2000/svg"><path d="M32.2591 28.6707C32.2591 32.3914 29.2421 35.407 25.5214 35.407C22.0752 35.407 19.2338 32.8206 18.8325 29.4831V29.4775C18.8143 29.3312 18.8018 29.1835 18.7934 29.0344C18.7934 29.0316 18.7921 29.0274 18.7921 29.0246V29.0177C18.7865 28.902 18.7837 28.7864 18.7837 28.6707C18.7837 26.2557 20.0532 24.1389 21.9609 22.9503C21.9623 22.9489 21.9651 22.9489 21.9665 22.9475C22.0933 22.8666 22.2243 22.7914 22.3581 22.7203C22.3581 22.7203 22.3595 22.7203 22.3595 22.7189C23.3029 22.2173 24.3787 21.933 25.5214 21.933C29.2421 21.933 32.2591 24.9486 32.2591 28.6707Z"></path><path d="M25.5214 14.0692C29.2421 14.0692 32.2591 11.0522 32.2591 7.33146C32.2591 3.61074 29.2421 0.59375 25.5214 0.59375C22.0529 0.59375 19.1962 3.21637 18.8255 6.58592C18.8185 6.67092 18.8116 6.75454 18.8018 6.83815C18.7893 7.00119 18.7837 7.16563 18.7837 7.33146C18.7837 9.73669 20.0434 11.8465 21.94 13.038C22.0891 13.116 22.2355 13.201 22.3776 13.2916C22.3783 13.2923 22.379 13.2926 22.3797 13.293C22.3804 13.2933 22.3811 13.2937 22.3818 13.2944C23.3196 13.7891 24.3871 14.0692 25.5214 14.0692Z"></path><path d="M19.3645 12.4113C20.2926 12.4113 21.1694 12.638 21.94 13.038C20.0434 11.8465 18.7837 9.73669 18.7837 7.33146C18.7837 7.16563 18.7893 7.00119 18.8018 6.83815C18.4688 9.76455 16.1385 12.0866 13.2065 12.4044C13.8545 13.1193 14.3785 13.9484 14.745 14.857C15.7497 13.3798 17.4443 12.4113 19.3645 12.4113Z"></path><path d="M14.7312 21.1249V21.1236C14.1279 20.2331 13.7767 19.1587 13.7767 18.0007V17.9728C13.7767 15.3084 12.2285 13.0035 9.9835 11.911C9.98141 11.9103 9.97967 11.9096 9.97793 11.9089C9.97619 11.9082 9.97444 11.9075 9.97235 11.9068C9.96817 11.904 9.96538 11.9026 9.9612 11.9012C9.95981 11.9012 9.95981 11.8998 9.95981 11.8998C9.9417 11.8915 9.92394 11.8831 9.90618 11.8747C9.8884 11.8664 9.87063 11.858 9.85251 11.8497C9.82046 11.8343 9.78701 11.819 9.75357 11.8051L9.74521 11.8009C8.91745 11.4372 8.0019 11.2351 7.03898 11.2351C3.31826 11.2351 0.30127 14.2521 0.30127 17.9728C0.30127 21.6935 3.31826 24.7105 7.03898 24.7105C7.98797 24.7105 8.89098 24.514 9.71037 24.1601C9.71246 24.1594 9.7142 24.1583 9.71594 24.1573C9.71768 24.1562 9.71943 24.1552 9.72152 24.1545C9.8107 24.1169 9.8985 24.0765 9.9849 24.0333L9.98629 24.0319C10.7625 23.6919 11.6181 23.5037 12.5197 23.5037C12.7524 23.5037 12.9824 23.5163 13.2081 23.54C13.2082 23.5399 13.2081 23.54 13.2081 23.54C15.0168 23.7365 16.5971 24.695 17.6185 26.0885C17.9195 25.1688 18.3752 24.3201 18.9563 23.5732C17.1964 23.4464 15.6635 22.5058 14.7312 21.1249Z"></path><g clip-path="url(#clip0)"><path d="M106.391 18.0021C106.391 11.3724 101.039 6 94.4389 6H88.4585C81.8581 6 76.5061 11.3724 76.5061 18.0021V30.0042H81.2845V18.0021C81.2845 14.0268 84.4941 10.8008 88.4585 10.8008H94.4347C98.395 10.8008 101.609 14.0226 101.609 18.0021V30.0042H106.391V18.0021Z"></path><path d="M149.432 6H142.258C135.653 6 130.301 11.3724 130.301 18.0021C130.301 24.6319 135.653 30.0042 142.258 30.0042H149.432C156.036 30.0042 161.388 24.6319 161.388 18.0021C161.388 11.3724 156.032 6 149.432 6ZM149.432 25.1992H142.258C138.297 25.1992 135.084 21.9774 135.084 17.9979C135.084 14.0183 138.293 10.7966 142.258 10.7966H149.432C153.392 10.7966 156.606 14.0183 156.606 17.9979C156.606 21.9774 153.392 25.1992 149.432 25.1992Z"></path><path d="M74.1151 25.1992H58.5736C55.4526 25.1992 52.804 23.1924 51.8171 20.3983H74.1151V17.9979C74.1151 17.1808 74.1868 16.3807 74.3175 15.5975H51.8171C52.804 12.8033 55.4526 10.7966 58.5736 10.7966H76.0383C77.1475 8.87458 78.6911 7.22773 80.5299 6H58.5736C51.969 6 46.6169 11.3724 46.6169 18.0021C46.6169 24.6276 51.969 30 58.5736 30H74.1151V25.1992Z"></path><path d="M120.74 6H115.958H102.369C104.212 7.22773 105.751 8.87458 106.861 10.8008H115.958V30H120.74V10.8008H129.838C130.947 8.87458 132.486 7.22773 134.329 6H120.74Z"></path><path d="M182.906 15.6017H169.756C168.436 15.6017 167.365 14.5264 167.365 13.2013C167.365 11.8762 168.436 10.8008 169.756 10.8008H188.882V6H169.756C165.796 6 162.582 9.22173 162.582 13.2013C162.582 17.1808 165.791 20.4025 169.756 20.4025H182.906C184.226 20.4025 185.297 21.4779 185.297 22.803C185.297 24.1281 184.226 25.2034 182.906 25.2034H161.852C160.743 27.1297 159.199 28.7765 157.361 30.0042H182.906C186.866 30.0042 190.08 26.7825 190.08 22.803C190.08 18.8234 186.866 15.6017 182.906 15.6017Z"></path></g><defs><clipPath id="clip0"><rect width="190" height="24" fill="white" transform="translate(0 6)"></rect></clipPath></defs></svg>
-                <div>
-                    Entos Envision
-                </div>
-            </a>
-        </div>
-        <script>
-            function getParam(name, regex) {
-                var r = new RegExp(name + '=' + '(' + regex + ')[&]?', 'i');
-                return decodeURIComponent(((window.location.search || '').match(r) || [])[1] || '');
-            }
-
-            var debugMode = getParam('debug-mode', '[^&]+').trim() === '1';
-            if (debugMode) AlphaOrbitalsExample.setDebugMode(debugMode);
-
-            var timingMode = getParam('timing-mode', '[^&]+').trim() === '1';
-            if (timingMode) AlphaOrbitalsExample.setTimingMode(timingMode);
-
-            AlphaOrbitalsExample.init('app')
-        </script>
-        <!-- __MOLSTAR_ANALYTICS__ -->
-    </body>
-</html>

src/examples/alpha-orbitals/index.ts

@@ -1,225 +0,0 @@
-/**
- * Copyright (c) 2020-2022 mol* contributors, licensed under MIT, See LICENSE file for more info.
- *
- * @author David Sehnal <david.sehnal@gmail.com>
- */
-
-import { BehaviorSubject } from 'rxjs';
-import { debounceTime, skip } from 'rxjs/operators';
-import { AlphaOrbital, Basis } from '../../extensions/alpha-orbitals/data-model';
-import { SphericalBasisOrder } from '../../extensions/alpha-orbitals/spherical-functions';
-import { BasisAndOrbitals, CreateOrbitalDensityVolume, CreateOrbitalRepresentation3D, CreateOrbitalVolume, StaticBasisAndOrbitals } from '../../extensions/alpha-orbitals/transforms';
-import { canComputeGrid3dOnGPU } from '../../mol-gl/compute/grid3d';
-import { PluginStateObject } from '../../mol-plugin-state/objects';
-import { createPluginUI } from '../../mol-plugin-ui/react18';
-import { PluginUIContext } from '../../mol-plugin-ui/context';
-import { DefaultPluginUISpec } from '../../mol-plugin-ui/spec';
-import { PluginCommands } from '../../mol-plugin/commands';
-import { PluginConfig } from '../../mol-plugin/config';
-import { StateObjectSelector, StateTransformer } from '../../mol-state';
-import { Color } from '../../mol-util/color';
-import { ColorNames } from '../../mol-util/color/names';
-import { ParamDefinition } from '../../mol-util/param-definition';
-import { mountControls } from './controls';
-import { DemoMoleculeSDF, DemoOrbitals } from './example-data';
-import './index.html';
-require('mol-plugin-ui/skin/light.scss');
-
-import { setDebugMode, setTimingMode } from '../../mol-util/debug';
-
-interface DemoInput {
-    moleculeSdf: string,
-    basis: Basis,
-    order: SphericalBasisOrder,
-    orbitals: AlphaOrbital[]
-}
-
-interface Params {
-    show: { name: 'orbital', params: { index: number } } | { name: 'density', params: {} },
-    isoValue: number,
-    gpuSurface: boolean
-}
-
-type Selectors = {
-    type: 'orbital',
-    volume: StateObjectSelector<PluginStateObject.Volume.Data, typeof CreateOrbitalVolume>,
-    positive: StateObjectSelector<PluginStateObject.Volume.Representation3D, typeof CreateOrbitalRepresentation3D>
-    negative: StateObjectSelector<PluginStateObject.Volume.Representation3D, typeof CreateOrbitalRepresentation3D>
-} | {
-    type: 'density',
-    volume: StateObjectSelector<PluginStateObject.Volume.Data, typeof CreateOrbitalDensityVolume>,
-    positive: StateObjectSelector<PluginStateObject.Volume.Representation3D, typeof CreateOrbitalRepresentation3D>
-}
-
-export class AlphaOrbitalsExample {
-    plugin: PluginUIContext;
-
-    async init(target: string | HTMLElement) {
-        const defaultSpec = DefaultPluginUISpec();
-        this.plugin = await createPluginUI(typeof target === 'string' ? document.getElementById(target)! : target, {
-            ...defaultSpec,
-            layout: {
-                initial: {
-                    isExpanded: false,
-                    showControls: false
-                },
-            },
-            components: {
-                controls: { left: 'none', right: 'none', top: 'none', bottom: 'none' },
-            },
-            canvas3d: {
-                camera: {
-                    helper: { axes: { name: 'off', params: {} } }
-                }
-            },
-            config: [
-                [PluginConfig.Viewport.ShowExpand, false],
-                [PluginConfig.Viewport.ShowControls, false],
-                [PluginConfig.Viewport.ShowSelectionMode, false],
-                [PluginConfig.Viewport.ShowAnimation, false],
-            ]
-        });
-
-        this.plugin.managers.interactivity.setProps({ granularity: 'element' });
-
-        if (!canComputeGrid3dOnGPU(this.plugin.canvas3d?.webgl)) {
-            PluginCommands.Toast.Show(this.plugin, {
-                title: 'Error',
-                message: `Browser/device does not support required WebGL extension (OES_texture_float).`
-            });
-            return;
-        }
-
-        this.load({
-            moleculeSdf: DemoMoleculeSDF,
-            ...DemoOrbitals
-        });
-
-        mountControls(this, document.getElementById('controls')!);
-    }
-
-    readonly params = new BehaviorSubject<ParamDefinition.For<Params>>({} as any);
-    readonly state = new BehaviorSubject<Params>({ show: { name: 'orbital', params: { index: 32 } }, isoValue: 1, gpuSurface: true });
-
-    private selectors?: Selectors = void 0;
-    private basis?: StateObjectSelector<BasisAndOrbitals> = void 0;
-
-    private currentParams: Params = { ...this.state.value };
-
-    private clearVolume() {
-        if (!this.selectors) return;
-        const v = this.selectors.volume;
-        this.selectors = void 0;
-        return this.plugin.build().delete(v).commit();
-    }
-
-    private async syncVolume() {
-        if (!this.basis?.isOk) return;
-
-        const state = this.state.value;
-
-        if (state.show.name !== this.selectors?.type) {
-            await this.clearVolume();
-        }
-
-        const update = this.plugin.build();
-        if (state.show.name === 'orbital') {
-            if (!this.selectors) {
-                const volume = update
-                    .to(this.basis)
-                    .apply(CreateOrbitalVolume, { index: state.show.params.index });
-
-                const positive = volume.apply(CreateOrbitalRepresentation3D, this.volumeParams('positive', ColorNames.blue)).selector;
-                const negative = volume.apply(CreateOrbitalRepresentation3D, this.volumeParams('negative', ColorNames.red)).selector;
-
-                this.selectors = { type: 'orbital', volume: volume.selector, positive, negative };
-            } else {
-                const index = state.show.params.index;
-                update.to(this.selectors.volume).update(CreateOrbitalVolume, () => ({ index }));
-            }
-        } else {
-            if (!this.selectors) {
-                const volume = update
-                    .to(this.basis)
-                    .apply(CreateOrbitalDensityVolume);
-                const positive = volume.apply(CreateOrbitalRepresentation3D, this.volumeParams('positive', ColorNames.blue)).selector;
-                this.selectors = { type: 'density', volume: volume.selector, positive };
-            }
-        }
-
-        await update.commit();
-
-        if (this.currentParams.gpuSurface !== this.state.value.gpuSurface) {
-            await this.setIsovalue();
-        }
-
-        this.currentParams = this.state.value;
-    }
-
-    private setIsovalue() {
-        if (!this.selectors) return;
-
-        this.currentParams = this.state.value;
-        const update = this.plugin.build();
-        update.to(this.selectors.positive).update(this.volumeParams('positive', ColorNames.blue));
-        if (this.selectors?.type === 'orbital') {
-            update.to(this.selectors.negative).update(this.volumeParams('negative', ColorNames.red));
-        }
-        return update.commit();
-    }
-
-    private volumeParams(kind: 'positive' | 'negative', color: Color): StateTransformer.Params<typeof CreateOrbitalRepresentation3D> {
-        return {
-            alpha: 0.85,
-            color,
-            kind,
-            relativeIsovalue: this.state.value.isoValue,
-            pickable: false,
-            xrayShaded: true,
-            tryUseGpu: true
-        };
-    }
-
-    async load(input: DemoInput) {
-        await this.plugin.clear();
-
-        const data = await this.plugin.builders.data.rawData({ data: input.moleculeSdf }, { state: { isGhost: true } });
-        const trajectory = await this.plugin.builders.structure.parseTrajectory(data, 'mol');
-        const model = await this.plugin.builders.structure.createModel(trajectory);
-        const structure = await this.plugin.builders.structure.createStructure(model);
-
-        const all = await this.plugin.builders.structure.tryCreateComponentStatic(structure, 'all');
-        if (all) await this.plugin.builders.structure.representation.addRepresentation(all, { type: 'ball-and-stick', color: 'element-symbol', colorParams: { carbonColor: { name: 'element-symbol', params: {} } } });
-
-
-        this.basis = await this.plugin.build().toRoot()
-            .apply(StaticBasisAndOrbitals, { basis: input.basis, order: input.order, orbitals: input.orbitals })
-            .commit();
-
-        await this.syncVolume();
-
-        this.params.next({
-            show: ParamDefinition.MappedStatic('orbital', {
-                'orbital': ParamDefinition.Group({
-                    index: ParamDefinition.Numeric(32, { min: 0, max: input.orbitals.length - 1 }, { immediateUpdate: true, isEssential: true }),
-                }),
-                'density': ParamDefinition.EmptyGroup()
-            }, { cycle: true }),
-            isoValue: ParamDefinition.Numeric(this.currentParams.isoValue, { min: 0.5, max: 3, step: 0.1 }, { immediateUpdate: true, isEssential: false }),
-            gpuSurface: ParamDefinition.Boolean(this.currentParams.gpuSurface, { isHidden: true })
-        });
-
-        this.state.pipe(skip(1), debounceTime(1000 / 24)).subscribe(async params => {
-            if (params.show.name !== this.currentParams.show.name
-                || (params.show.name === 'orbital' && this.currentParams.show.name === 'orbital' && params.show.params.index !== this.currentParams.show.params.index)) {
-                this.syncVolume();
-            } else if (params.isoValue !== this.currentParams.isoValue || params.gpuSurface !== this.currentParams.gpuSurface) {
-                this.setIsovalue();
-            }
-        });
-    }
-}
-
-(window as any).AlphaOrbitalsExample = new AlphaOrbitalsExample();
-(window as any).AlphaOrbitalsExample.setDebugMode = setDebugMode;
-(window as any).AlphaOrbitalsExample.setTimingMode = setTimingMode;

src/examples/basic-wrapper/controls.tsx

@@ -1,15 +0,0 @@
-/**
- * Copyright (c) 2019 mol* contributors, licensed under MIT, See LICENSE file for more info.
- *
- * @author David Sehnal <david.sehnal@gmail.com>
- */
-
-import { PluginUIComponent } from '../../mol-plugin-ui/base';
-
-export class CustomToastMessage extends PluginUIComponent {
-    render() {
-        return <>
-            Custom <i>Toast</i> content. No timeout.
-        </>;
-    }
-}

src/examples/basic-wrapper/custom-theme.ts

@@ -1,51 +0,0 @@
-import { isPositionLocation } from '../../mol-geo/util/location-iterator';
-import { Vec3 } from '../../mol-math/linear-algebra';
-import { ColorTheme } from '../../mol-theme/color';
-import { ThemeDataContext } from '../../mol-theme/theme';
-import { Color } from '../../mol-util/color';
-import { ColorNames } from '../../mol-util/color/names';
-import { ParamDefinition as PD } from '../../mol-util/param-definition';
-
-export function CustomColorTheme(
-    ctx: ThemeDataContext,
-    props: PD.Values<{}>
-): ColorTheme<{}> {
-    const { radius, center } = ctx.structure?.boundary.sphere!;
-    const radiusSq = Math.max(radius * radius, 0.001);
-    const scale = ColorTheme.PaletteScale;
-
-    return {
-        factory: CustomColorTheme,
-        granularity: 'vertex',
-        color: location => {
-            if (!isPositionLocation(location)) return ColorNames.black;
-            const dist = Vec3.squaredDistance(location.position, center);
-            const t = Math.min(dist / radiusSq, 1);
-            return ((t * scale) | 0) as Color;
-        },
-        palette: {
-            filter: 'nearest',
-            colors: [
-                ColorNames.red,
-                ColorNames.pink,
-                ColorNames.violet,
-                ColorNames.orange,
-                ColorNames.yellow,
-                ColorNames.green,
-                ColorNames.blue
-            ]
-        },
-        props: props,
-        description: '',
-    };
-}
-
-export const CustomColorThemeProvider: ColorTheme.Provider<{}, 'basic-wrapper-custom-color-theme'> = {
-    name: 'basic-wrapper-custom-color-theme',
-    label: 'Custom Color Theme',
-    category: ColorTheme.Category.Misc,
-    factory: CustomColorTheme,
-    getParams: () => ({}),
-    defaultValues: { },
-    isApplicable: (ctx: ThemeDataContext) => true,
-};

src/examples/basic-wrapper/index.ts

@@ -1,182 +0,0 @@
-/**
- * Copyright (c) 2019 mol* contributors, licensed under MIT, See LICENSE file for more info.
- *
- * @author David Sehnal <david.sehnal@gmail.com>
- */
-
-import { PDBeStructureQualityReport } from '../../extensions/pdbe';
-import { EmptyLoci } from '../../mol-model/loci';
-import { StructureSelection } from '../../mol-model/structure';
-import { AnimateModelIndex } from '../../mol-plugin-state/animation/built-in/model-index';
-import { BuiltInTrajectoryFormat } from '../../mol-plugin-state/formats/trajectory';
-import { createPluginUI } from '../../mol-plugin-ui/react18';
-import { PluginUIContext } from '../../mol-plugin-ui/context';
-import { DefaultPluginUISpec } from '../../mol-plugin-ui/spec';
-import { PluginCommands } from '../../mol-plugin/commands';
-import { Script } from '../../mol-script/script';
-import { Asset } from '../../mol-util/assets';
-import { Color } from '../../mol-util/color';
-import { StripedResidues } from './coloring';
-import { CustomToastMessage } from './controls';
-import { CustomColorThemeProvider } from './custom-theme';
-import './index.html';
-import { buildStaticSuperposition, dynamicSuperpositionTest, StaticSuperpositionTestData } from './superposition';
-require('mol-plugin-ui/skin/light.scss');
-
-type LoadParams = { url: string, format?: BuiltInTrajectoryFormat, isBinary?: boolean, assemblyId?: string }
-
-class BasicWrapper {
-    plugin: PluginUIContext;
-
-    async init(target: string | HTMLElement) {
-        this.plugin = await createPluginUI(typeof target === 'string' ? document.getElementById(target)! : target, {
-            ...DefaultPluginUISpec(),
-            layout: {
-                initial: {
-                    isExpanded: false,
-                    showControls: false
-                }
-            },
-            components: {
-                remoteState: 'none'
-            }
-        });
-
-        this.plugin.representation.structure.themes.colorThemeRegistry.add(StripedResidues.colorThemeProvider!);
-        this.plugin.representation.structure.themes.colorThemeRegistry.add(CustomColorThemeProvider);
-        this.plugin.managers.lociLabels.addProvider(StripedResidues.labelProvider!);
-        this.plugin.customModelProperties.register(StripedResidues.propertyProvider, true);
-    }
-
-    async load({ url, format = 'mmcif', isBinary = false, assemblyId = '' }: LoadParams) {
-        await this.plugin.clear();
-
-        const data = await this.plugin.builders.data.download({ url: Asset.Url(url), isBinary }, { state: { isGhost: true } });
-        const trajectory = await this.plugin.builders.structure.parseTrajectory(data, format);
-
-        await this.plugin.builders.structure.hierarchy.applyPreset(trajectory, 'default', {
-            structure: assemblyId ? {
-                name: 'assembly',
-                params: { id: assemblyId }
-            } : {
-                name: 'model',
-                params: {}
-            },
-            showUnitcell: false,
-            representationPreset: 'auto'
-        });
-    }
-
-    setBackground(color: number) {
-        PluginCommands.Canvas3D.SetSettings(this.plugin, { settings: props => { props.renderer.backgroundColor = Color(color); } });
-    }
-
-    toggleSpin() {
-        if (!this.plugin.canvas3d) return;
-
-        const trackball = this.plugin.canvas3d.props.trackball;
-        PluginCommands.Canvas3D.SetSettings(this.plugin, {
-            settings: {
-                trackball: {
-                    ...trackball,
-                    animate: trackball.animate.name === 'spin'
-                        ? { name: 'off', params: {} }
-                        : { name: 'spin', params: { speed: 1 } }
-                }
-            }
-        });
-        if (this.plugin.canvas3d.props.trackball.animate.name !== 'spin') {
-            PluginCommands.Camera.Reset(this.plugin, {});
-        }
-    }
-
-    private animateModelIndexTargetFps() {
-        return Math.max(1, this.animate.modelIndex.targetFps | 0);
-    }
-
-    animate = {
-        modelIndex: {
-            targetFps: 8,
-            onceForward: () => { this.plugin.managers.animation.play(AnimateModelIndex, { duration: { name: 'computed', params: { targetFps: this.animateModelIndexTargetFps() } }, mode: { name: 'once', params: { direction: 'forward' } } }); },
-            onceBackward: () => { this.plugin.managers.animation.play(AnimateModelIndex, { duration: { name: 'computed', params: { targetFps: this.animateModelIndexTargetFps() } }, mode: { name: 'once', params: { direction: 'backward' } } }); },
-            palindrome: () => { this.plugin.managers.animation.play(AnimateModelIndex, { duration: { name: 'computed', params: { targetFps: this.animateModelIndexTargetFps() } }, mode: { name: 'palindrome', params: {} } }); },
-            loop: () => { this.plugin.managers.animation.play(AnimateModelIndex, { duration: { name: 'computed', params: { targetFps: this.animateModelIndexTargetFps() } }, mode: { name: 'loop', params: { direction: 'forward' } } }); },
-            stop: () => this.plugin.managers.animation.stop()
-        }
-    };
-
-    coloring = {
-        applyStripes: async () => {
-            this.plugin.dataTransaction(async () => {
-                for (const s of this.plugin.managers.structure.hierarchy.current.structures) {
-                    await this.plugin.managers.structure.component.updateRepresentationsTheme(s.components, { color: StripedResidues.propertyProvider.descriptor.name as any });
-                }
-            });
-        },
-        applyCustomTheme: async () => {
-            this.plugin.dataTransaction(async () => {
-                for (const s of this.plugin.managers.structure.hierarchy.current.structures) {
-                    await this.plugin.managers.structure.component.updateRepresentationsTheme(s.components, { color: CustomColorThemeProvider.name as any });
-                }
-            });
-        },
-        applyDefault: async () => {
-            this.plugin.dataTransaction(async () => {
-                for (const s of this.plugin.managers.structure.hierarchy.current.structures) {
-                    await this.plugin.managers.structure.component.updateRepresentationsTheme(s.components, { color: 'default' });
-                }
-            });
-        }
-    };
-
-    interactivity = {
-        highlightOn: () => {
-            const data = this.plugin.managers.structure.hierarchy.current.structures[0]?.cell.obj?.data;
-            if (!data) return;
-
-            const seq_id = 7;
-            const sel = Script.getStructureSelection(Q => Q.struct.generator.atomGroups({
-                'residue-test': Q.core.rel.eq([Q.struct.atomProperty.macromolecular.label_seq_id(), seq_id]),
-                'group-by': Q.struct.atomProperty.macromolecular.residueKey()
-            }), data);
-            const loci = StructureSelection.toLociWithSourceUnits(sel);
-            this.plugin.managers.interactivity.lociHighlights.highlightOnly({ loci });
-        },
-        clearHighlight: () => {
-            this.plugin.managers.interactivity.lociHighlights.highlightOnly({ loci: EmptyLoci });
-        }
-    };
-
-    tests = {
-        staticSuperposition: async () => {
-            await this.plugin.clear();
-            return buildStaticSuperposition(this.plugin, StaticSuperpositionTestData);
-        },
-        dynamicSuperposition: async () => {
-            await this.plugin.clear();
-            return dynamicSuperpositionTest(this.plugin, ['1tqn', '2hhb', '4hhb'], 'HEM');
-        },
-        toggleValidationTooltip: () => {
-            return this.plugin.state.updateBehavior(PDBeStructureQualityReport, params => { params.showTooltip = !params.showTooltip; });
-        },
-        showToasts: () => {
-            PluginCommands.Toast.Show(this.plugin, {
-                title: 'Toast 1',
-                message: 'This is an example text, timeout 3s',
-                key: 'toast-1',
-                timeoutMs: 3000
-            });
-            PluginCommands.Toast.Show(this.plugin, {
-                title: 'Toast 2',
-                message: CustomToastMessage,
-                key: 'toast-2'
-            });
-        },
-        hideToasts: () => {
-            PluginCommands.Toast.Hide(this.plugin, { key: 'toast-1' });
-            PluginCommands.Toast.Hide(this.plugin, { key: 'toast-2' });
-        }
-    };
-}
-
-(window as any).BasicMolStarWrapper = new BasicWrapper();

src/examples/basic-wrapper/superposition.ts

@@ -1,119 +0,0 @@
-/**
- * Copyright (c) 2019 mol* contributors, licensed under MIT, See LICENSE file for more info.
- *
- * @author David Sehnal <david.sehnal@gmail.com>
- */
-
-import { Mat4 } from '../../mol-math/linear-algebra';
-import { QueryContext, StructureSelection } from '../../mol-model/structure';
-import { superpose } from '../../mol-model/structure/structure/util/superposition';
-import { PluginStateObject as PSO } from '../../mol-plugin-state/objects';
-import { PluginContext } from '../../mol-plugin/context';
-import { MolScriptBuilder as MS } from '../../mol-script/language/builder';
-import { Expression } from '../../mol-script/language/expression';
-import { compile } from '../../mol-script/runtime/query/compiler';
-import { StateObjectRef } from '../../mol-state';
-import { BuiltInTrajectoryFormat } from '../../mol-plugin-state/formats/trajectory';
-import { StateTransforms } from '../../mol-plugin-state/transforms';
-import { Asset } from '../../mol-util/assets';
-
-export type SuperpositionTestInput = {
-    pdbId: string,
-    auth_asym_id: string,
-    matrix: Mat4
-}[];
-
-export function buildStaticSuperposition(plugin: PluginContext, src: SuperpositionTestInput) {
-    return plugin.dataTransaction(async () => {
-        for (const s of src) {
-            const { structure } = await loadStructure(plugin, `https://www.ebi.ac.uk/pdbe/static/entry/${s.pdbId}_updated.cif`, 'mmcif');
-            await transform(plugin, structure, s.matrix);
-            const chain = await plugin.builders.structure.tryCreateComponentFromExpression(structure, chainSelection(s.auth_asym_id), `Chain ${s.auth_asym_id}`);
-            if (chain) await plugin.builders.structure.representation.addRepresentation(chain, { type: 'cartoon' });
-        }
-    });
-}
-
-export const StaticSuperpositionTestData: SuperpositionTestInput = [
-    {
-        pdbId: '1aj5', auth_asym_id: 'A', matrix: Mat4.identity()
-    },
-    {
-        pdbId: '1df0', auth_asym_id: 'B', matrix: Mat4.ofRows([
-            [0.406, 0.879, 0.248, -200.633],
-            [0.693, -0.473, 0.544, 73.403],
-            [0.596, -0.049, -0.802, -14.209],
-            [0, 0, 0, 1]])
-    },
-    {
-        pdbId: '1dvi', auth_asym_id: 'A', matrix: Mat4.ofRows([
-            [-0.053, -0.077, 0.996, -45.633],
-            [-0.312, 0.949, 0.057, -12.255],
-            [-0.949, -0.307, -0.074, 53.562],
-            [0, 0, 0, 1]])
-    }
-];
-
-export function dynamicSuperpositionTest(plugin: PluginContext, src: string[], comp_id: string) {
-    return plugin.dataTransaction(async () => {
-        for (const s of src) {
-            await loadStructure(plugin, `https://www.ebi.ac.uk/pdbe/static/entry/${s}_updated.cif`, 'mmcif');
-        }
-
-        const pivot = MS.struct.filter.first([
-            MS.struct.generator.atomGroups({
-                'residue-test': MS.core.rel.eq([MS.struct.atomProperty.macromolecular.label_comp_id(), comp_id]),
-                'group-by': MS.struct.atomProperty.macromolecular.residueKey()
-            })
-        ]);
-
-        const rest = MS.struct.modifier.exceptBy({
-            0: MS.struct.modifier.includeSurroundings({
-                0: pivot,
-                radius: 5
-            }),
-            by: pivot
-        });
-
-        const query = compile<StructureSelection>(pivot);
-        const xs = plugin.managers.structure.hierarchy.current.structures;
-        const selections = xs.map(s => StructureSelection.toLociWithCurrentUnits(query(new QueryContext(s.cell.obj!.data))));
-
-        const transforms = superpose(selections);
-
-        await siteVisual(plugin, xs[0].cell, pivot, rest);
-        for (let i = 1; i < selections.length; i++) {
-            await transform(plugin, xs[i].cell, transforms[i - 1].bTransform);
-            await siteVisual(plugin, xs[i].cell, pivot, rest);
-        }
-    });
-}
-
-async function siteVisual(plugin: PluginContext, s: StateObjectRef<PSO.Molecule.Structure>, pivot: Expression, rest: Expression) {
-    const center = await plugin.builders.structure.tryCreateComponentFromExpression(s, pivot, 'pivot');
-    if (center) await plugin.builders.structure.representation.addRepresentation(center, { type: 'ball-and-stick', color: 'residue-name' });
-
-    const surr = await plugin.builders.structure.tryCreateComponentFromExpression(s, rest, 'rest');
-    if (surr) await plugin.builders.structure.representation.addRepresentation(surr, { type: 'ball-and-stick', color: 'uniform', size: 'uniform', sizeParams: { value: 0.33 } });
-}
-
-async function loadStructure(plugin: PluginContext, url: string, format: BuiltInTrajectoryFormat, assemblyId?: string) {
-    const data = await plugin.builders.data.download({ url: Asset.Url(url) });
-    const trajectory = await plugin.builders.structure.parseTrajectory(data, format);
-    const model = await plugin.builders.structure.createModel(trajectory);
-    const structure = await plugin.builders.structure.createStructure(model, assemblyId ? { name: 'assembly', params: { id: assemblyId } } : void 0);
-
-    return { data, trajectory, model, structure };
-}
-
-function chainSelection(auth_asym_id: string) {
-    return MS.struct.generator.atomGroups({
-        'chain-test': MS.core.rel.eq([MS.struct.atomProperty.macromolecular.auth_asym_id(), auth_asym_id])
-    });
-}
-
-function transform(plugin: PluginContext, s: StateObjectRef<PSO.Molecule.Structure>, matrix: Mat4) {
-    const b = plugin.state.data.build().to(s)
-        .insert(StateTransforms.Model.TransformStructureConformation, { transform: { name: 'matrix', params: { data: matrix, transpose: false } } });
-    return plugin.runTask(plugin.state.data.updateTree(b));
-}

src/examples/lighting/index.ts

@@ -1,132 +0,0 @@
-/**
- * Copyright (c) 2019-2021 mol* contributors, licensed under MIT, See LICENSE file for more info.
- *
- * @author Alexander Rose <alexander.rose@weirdbyte.de>
- */
-
-import { Canvas3DProps } from '../../mol-canvas3d/canvas3d';
-import { BuiltInTrajectoryFormat } from '../../mol-plugin-state/formats/trajectory';
-import { createPluginUI } from '../../mol-plugin-ui/react18';
-import { PluginUIContext } from '../../mol-plugin-ui/context';
-import { DefaultPluginUISpec } from '../../mol-plugin-ui/spec';
-import { PluginCommands } from '../../mol-plugin/commands';
-import { Asset } from '../../mol-util/assets';
-import { Color } from '../../mol-util/color';
-import './index.html';
-require('mol-plugin-ui/skin/light.scss');
-
-type LoadParams = { url: string, format?: BuiltInTrajectoryFormat, isBinary?: boolean, assemblyId?: string }
-
-type _Preset = Pick<Canvas3DProps, 'postprocessing' | 'renderer'>
-type Preset = { [K in keyof _Preset]: Partial<_Preset[K]> }
-
-const Canvas3DPresets = {
-    illustrative: {
-        canvas3d: <Preset>{
-            postprocessing: {
-                occlusion: { name: 'on', params: { samples: 32, radius: 6, bias: 1.4, blurKernelSize: 15, resolutionScale: 1 } },
-                outline: { name: 'on', params: { scale: 1, threshold: 0.33, color: Color(0x000000) } }
-            },
-            renderer: {
-                ambientIntensity: 1.0,
-                light: []
-            }
-        }
-    },
-    occlusion: {
-        canvas3d: <Preset>{
-            postprocessing: {
-                occlusion: { name: 'on', params: { samples: 32, radius: 6, bias: 1.4, blurKernelSize: 15, resolutionScale: 1 } },
-                outline: { name: 'off', params: {} }
-            },
-            renderer: {
-                ambientIntensity: 0.4,
-                light: [{ inclination: 180, azimuth: 0, color: Color.fromNormalizedRgb(1.0, 1.0, 1.0),
-                    intensity: 0.6 }]
-            }
-        }
-    },
-    standard: {
-        canvas3d: <Preset>{
-            postprocessing: {
-                occlusion: { name: 'off', params: {} },
-                outline: { name: 'off', params: {} }
-            },
-            renderer: {
-                ambientIntensity: 0.4,
-                light: [{ inclination: 180, azimuth: 0, color: Color.fromNormalizedRgb(1.0, 1.0, 1.0),
-                    intensity: 0.6 }]
-            }
-        }
-    }
-};
-
-
-type Canvas3DPreset = keyof typeof Canvas3DPresets
-
-class LightingDemo {
-    plugin: PluginUIContext;
-
-    private radius = 5;
-    private bias = 1.1;
-    private preset: Canvas3DPreset = 'illustrative';
-
-    async init(target: string | HTMLElement) {
-        this.plugin = await createPluginUI(typeof target === 'string' ? document.getElementById(target)! : target, {
-            ...DefaultPluginUISpec(),
-            layout: {
-                initial: {
-                    isExpanded: false,
-                    showControls: false
-                },
-            },
-            components: {
-                controls: { left: 'none', right: 'none', top: 'none', bottom: 'none' }
-            }
-        });
-
-        this.setPreset('illustrative');
-    }
-
-    setPreset(preset: Canvas3DPreset) {
-        const props = Canvas3DPresets[preset];
-        if (props.canvas3d.postprocessing.occlusion?.name === 'on') {
-            props.canvas3d.postprocessing.occlusion.params.radius = this.radius;
-            props.canvas3d.postprocessing.occlusion.params.bias = this.bias;
-        }
-        PluginCommands.Canvas3D.SetSettings(this.plugin, {
-            settings: {
-                ...props,
-                renderer: {
-                    ...this.plugin.canvas3d!.props.renderer,
-                    ...props.canvas3d.renderer
-                },
-                postprocessing: {
-                    ...this.plugin.canvas3d!.props.postprocessing,
-                    ...props.canvas3d.postprocessing
-                },
-            }
-        });
-    }
-
-    async load({ url, format = 'mmcif', isBinary = true, assemblyId = '' }: LoadParams, radius: number, bias: number) {
-        await this.plugin.clear();
-
-        const data = await this.plugin.builders.data.download({ url: Asset.Url(url), isBinary }, { state: { isGhost: true } });
-        const trajectory = await this.plugin.builders.structure.parseTrajectory(data, format);
-        const model = await this.plugin.builders.structure.createModel(trajectory);
-        const structure = await this.plugin.builders.structure.createStructure(model, assemblyId ? { name: 'assembly', params: { id: assemblyId } } : { name: 'model', params: {} });
-
-        const polymer = await this.plugin.builders.structure.tryCreateComponentStatic(structure, 'polymer');
-        if (polymer) await this.plugin.builders.structure.representation.addRepresentation(polymer, { type: 'spacefill', color: 'illustrative' });
-
-        const ligand = await this.plugin.builders.structure.tryCreateComponentStatic(structure, 'ligand');
-        if (ligand) await this.plugin.builders.structure.representation.addRepresentation(ligand, { type: 'ball-and-stick', color: 'element-symbol', colorParams: { carbonColor: { name: 'element-symbol', params: {} } } });
-
-        this.radius = radius;
-        this.bias = bias;
-        this.setPreset(this.preset);
-    }
-}
-
-(window as any).LightingDemo = new LightingDemo();

src/examples/proteopedia-wrapper/annotation.ts

@@ -1,15 +1,12 @@
 /**
- * Copyright (c) 2019-2020 mol* contributors, licensed under MIT, See LICENSE file for more info.
+ * Copyright (c) 2019 mol* contributors, licensed under MIT, See LICENSE file for more info.
  *
  * @author David Sehnal <david.sehnal@gmail.com>
- * @author Alexander Rose <alexander.rose@weirdbyte.de>
  */
 
 import { CustomElementProperty } from '../../mol-model-props/common/custom-element-property';
 import { Model, ElementIndex, ResidueIndex } from '../../mol-model/structure';
 import { Color } from '../../mol-util/color';
-import { CustomProperty } from '../../mol-model-props/common/custom-property';
-import { Asset } from '../../mol-util/assets';
 
 const EvolutionaryConservationPalette: Color[] = [
     [255, 255, 129], // insufficient
@@ -26,14 +23,14 @@ const EvolutionaryConservationPalette: Color[] = [
 const EvolutionaryConservationDefaultColor = Color(0x999999);
 
 export const EvolutionaryConservation = CustomElementProperty.create<number>({
+    isStatic: true,
     name: 'proteopedia-wrapper-evolutionary-conservation',
-    label: 'Evolutionary Conservation',
-    type: 'static',
-    async getData(model: Model, ctx: CustomProperty.Context) {
+    display: 'Evolutionary Conservation',
+    async getData(model: Model) {
         const id = model.entryId.toLowerCase();
-        const url = Asset.getUrlAsset(ctx.assetManager, `https://proteopedia.org/cgi-bin/cnsrf?${id}`);
-        const json = await ctx.assetManager.resolve(url, 'json').runInContext(ctx.runtime);
-        const annotations = json.data?.residueAnnotations || [];
+        const req = await fetch(`https://proteopedia.org/cgi-bin/cnsrf?${id}`);
+        const json = await req.json();
+        const annotations = (json && json.residueAnnotations) || [];
 
         const conservationMap = new Map<string, number>();
 
@@ -59,7 +56,7 @@ export const EvolutionaryConservation = CustomElementProperty.create<number>({
             }
         }
 
-        return { value: map, assets: [json] };
+        return map;
     },
     coloring: {
         getColor(e: number) {
@@ -68,8 +65,8 @@ export const EvolutionaryConservation = CustomElementProperty.create<number>({
         },
         defaultColor: EvolutionaryConservationDefaultColor
     },
-    getLabel(e) {
-        if (e === 10) return `Evolutionary Conservation: Insufficient Data`;
+    format(e) {
+        if (e === 10) return `Evolutionary Conservation: InsufficientData`;
         return e ? `Evolutionary Conservation: ${e}` : void 0;
     }
 });

src/examples/proteopedia-wrapper/coloring.ts

@@ -6,63 +6,63 @@
  */
 
 
-import { Unit, StructureProperties, StructureElement, Bond } from '../../mol-model/structure';
+import { Unit, StructureProperties, StructureElement, Link } from '../../mol-model/structure';
 
 import { Color } from '../../mol-util/color';
 import { Location } from '../../mol-model/location';
 import { ColorTheme, LocationColor } from '../../mol-theme/color';
-import { ParamDefinition as PD } from '../../mol-util/param-definition';
+import { ParamDefinition as PD } from '../../mol-util/param-definition'
 import { ThemeDataContext } from '../../mol-theme/theme';
 import { Column } from '../../mol-data/db';
 
-const Description = 'Gives every chain a color from a list based on its `asym_id` value.';
+const Description = 'Gives every chain a color from a list based on its `asym_id` value.'
 
 export function createProteopediaCustomTheme(colors: number[]) {
     const ProteopediaCustomColorThemeParams = {
         colors: PD.ObjectList({ color: PD.Color(Color(0xffffff)) }, ({ color }) => Color.toHexString(color),
             { defaultValue: colors.map(c => ({ color: Color(c) })) })
-    };
+    }
     type ProteopediaCustomColorThemeParams = typeof ProteopediaCustomColorThemeParams
     function getChainIdColorThemeParams(ctx: ThemeDataContext) {
-        return ProteopediaCustomColorThemeParams; // TODO return copy
+        return ProteopediaCustomColorThemeParams // TODO return copy
     }
 
     function getAsymId(unit: Unit): StructureElement.Property<string> {
         switch (unit.kind) {
             case Unit.Kind.Atomic:
-                return StructureProperties.chain.label_asym_id;
+                return StructureProperties.chain.label_asym_id
             case Unit.Kind.Spheres:
             case Unit.Kind.Gaussians:
-                return StructureProperties.coarse.asym_id;
+                return StructureProperties.coarse.asym_id
         }
     }
 
     function addAsymIds(map: Map<string, number>, data: Column<string>) {
-        let j = map.size;
+        let j = map.size
         for (let o = 0, ol = data.rowCount; o < ol; ++o) {
-            const k = data.value(o);
+            const k = data.value(o)
             if (!map.has(k)) {
-                map.set(k, j);
-                j += 1;
+                map.set(k, j)
+                j += 1
             }
         }
     }
 
     function ProteopediaCustomColorTheme(ctx: ThemeDataContext, props: PD.Values<ProteopediaCustomColorThemeParams>): ColorTheme<ProteopediaCustomColorThemeParams> {
-        let color: LocationColor;
+        let color: LocationColor
 
         const colors = props.colors, colorCount = colors.length, defaultColor = colors[0].color;
 
         if (ctx.structure) {
-            const l = StructureElement.Location.create(ctx.structure);
-            const { models } = ctx.structure;
-            const asymIdSerialMap = new Map<string, number>();
+            const l = StructureElement.Location.create()
+            const { models } = ctx.structure
+            const asymIdSerialMap = new Map<string, number>()
             for (let i = 0, il = models.length; i < il; ++i) {
-                const m = models[i];
-                addAsymIds(asymIdSerialMap, m.atomicHierarchy.chains.label_asym_id);
+                const m = models[i]
+                addAsymIds(asymIdSerialMap, m.atomicHierarchy.chains.label_asym_id)
                 if (m.coarseHierarchy.isDefined) {
-                    addAsymIds(asymIdSerialMap, m.coarseHierarchy.spheres.asym_id);
-                    addAsymIds(asymIdSerialMap, m.coarseHierarchy.gaussians.asym_id);
+                    addAsymIds(asymIdSerialMap, m.coarseHierarchy.spheres.asym_id)
+                    addAsymIds(asymIdSerialMap, m.coarseHierarchy.gaussians.asym_id)
                 }
             }
 
@@ -71,17 +71,17 @@ export function createProteopediaCustomTheme(colors: number[]) {
                     const asym_id = getAsymId(location.unit);
                     const o = asymIdSerialMap.get(asym_id(location)) || 0;
                     return colors[o % colorCount].color;
-                } else if (Bond.isLocation(location)) {
-                    const asym_id = getAsymId(location.aUnit);
-                    l.unit = location.aUnit;
-                    l.element = location.aUnit.elements[location.aIndex];
+                } else if (Link.isLocation(location)) {
+                    const asym_id = getAsymId(location.aUnit)
+                    l.unit = location.aUnit
+                    l.element = location.aUnit.elements[location.aIndex]
                     const o = asymIdSerialMap.get(asym_id(l)) || 0;
                     return colors[o % colorCount].color;
                 }
-                return defaultColor;
-            };
+                return defaultColor
+            }
         } else {
-            color = () => defaultColor;
+            color = () => defaultColor
         }
 
         return {
@@ -91,16 +91,16 @@ export function createProteopediaCustomTheme(colors: number[]) {
             props,
             description: Description,
             legend: undefined
-        };
+        }
     }
 
-    return {
-        name: 'proteopedia-custom',
+    const ProteopediaCustomColorThemeProvider: ColorTheme.Provider<ProteopediaCustomColorThemeParams> = {
         label: 'Proteopedia Custom',
-        category: 'Custom',
         factory: ProteopediaCustomColorTheme,
         getParams: getChainIdColorThemeParams,
         defaultValues: PD.getDefaultValues(ProteopediaCustomColorThemeParams),
         isApplicable: (ctx: ThemeDataContext) => !!ctx.structure
-    };
+    }
+
+    return ProteopediaCustomColorThemeProvider;
 }

src/examples/proteopedia-wrapper/helpers.ts

@@ -4,11 +4,11 @@
  * @author David Sehnal <david.sehnal@gmail.com>
  */
 
-import { ModelSymmetry } from '../../mol-model-formats/structure/property/symmetry';
-import { Model, ResidueIndex } from '../../mol-model/structure';
+import { ResidueIndex, Model } from '../../mol-model/structure';
+import { BuiltInStructureRepresentationsName } from '../../mol-repr/structure/registry';
+import { BuiltInColorThemeName } from '../../mol-theme/color';
+import { AminoAcidNames } from '../../mol-model/structure/model/types';
 import { PluginContext } from '../../mol-plugin/context';
-import { StructureRepresentationRegistry } from '../../mol-repr/structure/registry';
-import { ColorTheme } from '../../mol-theme/color';
 
 export interface ModelInfo {
     hetResidues: { name: string, indices: ResidueIndex[] }[],
@@ -53,12 +53,14 @@ export namespace ModelInfo {
         const hetMap = new Map<string, ModelInfo['hetResidues'][0]>();
 
         for (let rI = 0 as ResidueIndex; rI < residueCount; rI++) {
+            const comp_id = model.atomicHierarchy.residues.label_comp_id.value(rI);
+            if (AminoAcidNames.has(comp_id)) continue;
+            const mod_parent = model.properties.modifiedResidues.parentId.get(comp_id);
+            if (mod_parent && AminoAcidNames.has(mod_parent)) continue;
+
             const cI = chainIndex[residueOffsets[rI]];
             const eI = model.atomicHierarchy.index.getEntityFromChain(cI);
-            const entityType = model.entities.data.type.value(eI);
-            if (entityType !== 'non-polymer' && entityType !== 'branched') continue;
-
-            const comp_id = model.atomicHierarchy.atoms.label_comp_id.value(residueOffsets[rI]);
+            if (model.entities.data.type.value(eI) === 'water') continue;
 
             let lig = hetMap.get(comp_id);
             if (!lig) {
@@ -70,11 +72,10 @@ export namespace ModelInfo {
         }
 
         const preferredAssemblyId = await pref;
-        const symmetry = ModelSymmetry.Provider.get(model);
 
         return {
             hetResidues: hetResidues,
-            assemblies: symmetry ? symmetry.assemblies.map(a => ({ id: a.id, details: a.details, isPreferred: a.id === preferredAssemblyId })) : [],
+            assemblies: model.symmetry.assemblies.map(a => ({ id: a.id, details: a.details, isPreferred: a.id === preferredAssemblyId })),
             preferredAssemblyId
         };
     }
@@ -84,7 +85,6 @@ export type SupportedFormats = 'cif' | 'pdb'
 export interface LoadParams {
     url: string,
     format?: SupportedFormats,
-    isBinary?: boolean,
     assemblyId?: string,
     representationStyle?: RepresentationStyle
 }
@@ -97,7 +97,7 @@ export interface RepresentationStyle {
 }
 
 export namespace RepresentationStyle {
-    export type Entry = { hide?: boolean, kind?: StructureRepresentationRegistry.BuiltIn, coloring?: ColorTheme.BuiltIn }
+    export type Entry = { hide?: boolean, kind?: BuiltInStructureRepresentationsName, coloring?: BuiltInColorThemeName }
 }
 
 export enum StateElements {

src/examples/proteopedia-wrapper/index.html

@@ -48,7 +48,7 @@
                 width: 300px;
             }
         </style>
-        <link rel="stylesheet" type="text/css" href="molstar.css" />
+        <link rel="stylesheet" type="text/css" href="app.css" />
         <script type="text/javascript" src="./index.js"></script>
     </head>
     <body>
@@ -60,12 +60,11 @@
                 <option value='cif' selected>CIF</option>
                 <option value='pdb'>PDB</option>
             </select>
-            <input type='checkbox' id='isBinary' style="display: inline-block; width: auto" /> <label for="isBinary"> Binary</label><br />
         </div>
         <div id="app"></div>
         <div id="volume-streaming-wrapper"></div>
         <script>
-            // it might be a good idea to define these colors in a separate script file
+            // it might be a good idea to define these colors in a separate script file 
             var CustomColors = [0x00ff00, 0x0000ff];
 
             // create an instance of the plugin
@@ -74,28 +73,24 @@
             console.log('Wrapper version', MolStarProteopediaWrapper.VERSION_MAJOR, MolStarProteopediaWrapper.VERSION_MINOR);
 
             function $(id) { return document.getElementById(id); }
-
-            var pdbId = '1cbs', assemblyId= 'preferred', isBinary = true;
-            var url = 'https://www.ebi.ac.uk/pdbe/entry-files/download/' + pdbId + '.bcif'
+        
+            var pdbId = '1cbs', assemblyId= 'preferred';
+            var url = 'https://www.ebi.ac.uk/pdbe/static/entry/' + pdbId + '_updated.cif';
             var format = 'cif';
-
+            
             $('url').value = url;
             $('url').onchange = function (e) { url = e.target.value; }
             $('assemblyId').value = assemblyId;
             $('assemblyId').onchange = function (e) { assemblyId = e.target.value; }
             $('format').value = format;
             $('format').onchange = function (e) { format = e.target.value; }
-            $('isBinary').checked = isBinary;
-            $('isBinary').onchange = function (e) { isBinary = !!e.target.checked; };
 
-            function loadAndSnapshot(params) {
-                PluginWrapper.load(params).then(() => {
-                    setTimeout(() => snapshot = PluginWrapper.plugin.state.getSnapshot({ canvas3d: false /* do not save spinning state */ }), 500);
-                });
-            }
+            // var url = 'https://www.ebi.ac.uk/pdbe/entry-files/pdb' + pdbId + '.ent';
+            // var format = 'pdb';
+            // var assemblyId = 'deposited';
 
             var representationStyle = {
-                // sequence: { coloring: 'proteopedia-custom' }, // or just { }
+                sequence: { coloring: 'proteopedia-custom' }, // or just { }
                 hetGroups: { kind: 'ball-and-stick' }, // or 'spacefill
                 water: { hide: true },
                 snfg3d: { hide: false }
@@ -103,19 +98,18 @@
 
             PluginWrapper.init('app' /** or document.getElementById('app') */, {
                 customColorList: CustomColors
-            }).then(() => {
-                PluginWrapper.setBackground(0xffffff);
-                loadAndSnapshot({ url: url, format: format, isBinary: isBinary, assemblyId: assemblyId, representationStyle: representationStyle });
-                PluginWrapper.toggleSpin();
             });
+            PluginWrapper.setBackground(0xffffff);
+            PluginWrapper.load({ url: url, format: format, assemblyId: assemblyId, representationStyle: representationStyle });
+            PluginWrapper.toggleSpin();
 
             PluginWrapper.events.modelInfo.subscribe(function (info) {
                 console.log('Model Info', info);
                 listHetGroups(info);
             });
 
-            addControl('Load Asym Unit', () => loadAndSnapshot({ url: url, format: format, isBinary }));
-            addControl('Load Assembly', () => loadAndSnapshot({ url: url, format: format, isBinary, assemblyId: assemblyId }));
+            addControl('Load Asym Unit', () => PluginWrapper.load({ url: url, format: format }));
+            addControl('Load Assembly', () => PluginWrapper.load({ url: url, format: format, assemblyId: assemblyId }));
 
             addSeparator();
 
@@ -141,14 +135,14 @@
             // Same as "wheel icon" and Viewport options
             // addControl('Clip', () => PluginWrapper.viewport.setSettings({ clip: [33, 66] }));
             // addControl('Reset Clip', () => PluginWrapper.viewport.setSettings({ clip: [1, 100] }));
-
+            
             addSeparator();
 
             addHeader('Animation');
 
             // adjust this number to make the animation faster or slower
             // requires to "restart" the animation if changed
-            PluginWrapper.animate.modelIndex.targetFps = 30;
+            PluginWrapper.animate.modelIndex.maxFPS = 30;
 
             addControl('Play To End', () => PluginWrapper.animate.modelIndex.onceForward());
             addControl('Play To Start', () => PluginWrapper.animate.modelIndex.onceBackward());
@@ -174,24 +168,20 @@
             addControl('Init', () => PluginWrapper.experimentalData.init($('volume-streaming-wrapper')));
             addControl('Remove', () => PluginWrapper.experimentalData.remove());
 
-            addSeparator();
+            addSeparator(); 
             addHeader('State');
 
             var snapshot;
-            addControl('Set Snapshot', () => {
-                // const options = { data: true, behavior: false, animation: false, interactivity: false, canvas3d: false, camera: false, cameraTransition: false };
-                snapshot = PluginWrapper.plugin.state.getSnapshot(/** options */);
-                // console.log(JSON.stringify(snapshot, null, 2));
+            addControl('Create Snapshot', () => {
+                snapshot = PluginWrapper.snapshot.get();
+                // could use JSON.stringify(snapshot) and upload the data
             });
-            addControl('Restore Snapshot', () => {
+            addControl('Apply Snapshot', () => {
                 if (!snapshot) return;
                 PluginWrapper.snapshot.set(snapshot);
-            });
-            addControl('Download State', () => {
-                PluginWrapper.snapshot.download('molj');
-            });
-            addControl('Download Session', () => {
-                PluginWrapper.snapshot.download('molx');
+
+                // or download snapshot using fetch or ajax or whatever
+                // or PluginWrapper.snapshot.download(url);
             });
 
             ////////////////////////////////////////////////////////
@@ -227,7 +217,7 @@
                     var l = document.createElement('button');
                     l.innerText = r.name;
                     l.onclick = function () {
-                        PluginWrapper.hetGroups.focusFirst(r.name, { doNotLabelWaters: true });
+                        PluginWrapper.hetGroups.focusFirst(r.name);
                     };
                     div.appendChild(l);
                 });

src/examples/proteopedia-wrapper/index.ts

@@ -5,35 +5,38 @@
  */
 
 import * as ReactDOM from 'react-dom';
-import { Canvas3DProps, DefaultCanvas3DParams } from '../../mol-canvas3d/canvas3d';
-import { AnimateModelIndex } from '../../mol-plugin-state/animation/built-in/model-index';
-import { createStructureRepresentationParams } from '../../mol-plugin-state/helpers/structure-representation-params';
-import { PluginStateObject, PluginStateObject as PSO } from '../../mol-plugin-state/objects';
-import { StateTransforms } from '../../mol-plugin-state/transforms';
-import { createPluginUI } from '../../mol-plugin-ui/react18';
-import { PluginUIContext } from '../../mol-plugin-ui/context';
-import { DefaultPluginUISpec } from '../../mol-plugin-ui/spec';
-import { CreateVolumeStreamingInfo, InitVolumeStreaming } from '../../mol-plugin/behavior/dynamic/volume-streaming/transformers';
-import { PluginCommands } from '../../mol-plugin/commands';
-import { PluginState } from '../../mol-plugin/state';
-import { MolScriptBuilder as MS } from '../../mol-script/language/builder';
-import { StateBuilder, StateObject, StateSelection } from '../../mol-state';
-import { Asset } from '../../mol-util/assets';
+import { createPlugin, DefaultPluginSpec } from '../../mol-plugin';
+import './index.html'
+import { PluginContext } from '../../mol-plugin/context';
+import { PluginCommands } from '../../mol-plugin/command';
+import { StateTransforms } from '../../mol-plugin/state/transforms';
+import { StructureRepresentation3DHelpers } from '../../mol-plugin/state/transforms/representation';
 import { Color } from '../../mol-util/color';
-import { ColorNames } from '../../mol-util/color/names';
-import { getFormattedTime } from '../../mol-util/date';
-import { download } from '../../mol-util/download';
-import { RxEventHelper } from '../../mol-util/rx-event-helper';
+import { PluginStateObject as PSO, PluginStateObject } from '../../mol-plugin/state/objects';
+import { AnimateModelIndex } from '../../mol-plugin/state/animation/built-in';
+import { StateBuilder, StateObject, StateSelection } from '../../mol-state';
 import { EvolutionaryConservation } from './annotation';
+import { LoadParams, SupportedFormats, RepresentationStyle, ModelInfo, StateElements } from './helpers';
+import { RxEventHelper } from '../../mol-util/rx-event-helper';
+import { ControlsWrapper, volumeStreamingControls } from './ui/controls';
+import { PluginState } from '../../mol-plugin/state';
+import { Scheduler } from '../../mol-task';
 import { createProteopediaCustomTheme } from './coloring';
-import { LoadParams, ModelInfo, RepresentationStyle, StateElements, SupportedFormats } from './helpers';
-import './index.html';
-import { volumeStreamingControls } from './ui/controls';
-require('../../mol-plugin-ui/skin/light.scss');
+import { MolScriptBuilder as MS } from '../../mol-script/language/builder';
+import { BuiltInStructureRepresentations } from '../../mol-repr/structure/registry';
+import { BuiltInColorThemes } from '../../mol-theme/color';
+import { BuiltInSizeThemes } from '../../mol-theme/size';
+import { ColorNames } from '../../mol-util/color/names';
+import { InitVolumeStreaming, CreateVolumeStreamingInfo } from '../../mol-plugin/behavior/dynamic/volume-streaming/transformers';
+import { DefaultCanvas3DParams, Canvas3DProps } from '../../mol-canvas3d/canvas3d';
+// import { Vec3 } from 'mol-math/linear-algebra';
+// import { ParamDefinition } from 'mol-util/param-definition';
+// import { Text } from 'mol-geo/geometry/text/text';
+require('../../mol-plugin/skin/light.scss')
 
 class MolStarProteopediaWrapper {
-    static VERSION_MAJOR = 5;
-    static VERSION_MINOR = 5;
+    static VERSION_MAJOR = 3;
+    static VERSION_MINOR = 4;
 
     private _ev = RxEventHelper.create();
 
@@ -41,13 +44,13 @@ class MolStarProteopediaWrapper {
         modelInfo: this._ev<ModelInfo>()
     };
 
-    plugin: PluginUIContext;
+    plugin: PluginContext;
 
-    async init(target: string | HTMLElement, options?: {
+    init(target: string | HTMLElement, options?: {
         customColorList?: number[]
     }) {
-        this.plugin = await createPluginUI(typeof target === 'string' ? document.getElementById(target)! : target, {
-            ...DefaultPluginUISpec(),
+        this.plugin = createPlugin(typeof target === 'string' ? document.getElementById(target)! : target, {
+            ...DefaultPluginSpec,
             animations: [
                 AnimateModelIndex
             ],
@@ -55,27 +58,27 @@ class MolStarProteopediaWrapper {
                 initial: {
                     isExpanded: false,
                     showControls: false
+                },
+                controls: {
+                    right: ControlsWrapper
                 }
-            },
-            components: {
-                remoteState: 'none'
             }
         });
 
         const customColoring = createProteopediaCustomTheme((options && options.customColorList) || []);
 
-        this.plugin.representation.structure.themes.colorThemeRegistry.add(customColoring);
-        this.plugin.representation.structure.themes.colorThemeRegistry.add(EvolutionaryConservation.colorThemeProvider!);
-        this.plugin.managers.lociLabels.addProvider(EvolutionaryConservation.labelProvider!);
-        this.plugin.customModelProperties.register(EvolutionaryConservation.propertyProvider, true);
+        this.plugin.structureRepresentation.themeCtx.colorThemeRegistry.add('proteopedia-custom', customColoring);
+        this.plugin.structureRepresentation.themeCtx.colorThemeRegistry.add(EvolutionaryConservation.Descriptor.name, EvolutionaryConservation.colorTheme!);
+        this.plugin.lociLabels.addProvider(EvolutionaryConservation.labelProvider);
+        this.plugin.customModelProperties.register(EvolutionaryConservation.propertyProvider);
     }
 
     get state() {
-        return this.plugin.state.data;
+        return this.plugin.state.dataState;
     }
 
-    private download(b: StateBuilder.To<PSO.Root>, url: string, isBinary: boolean) {
-        return b.apply(StateTransforms.Data.Download, { url: Asset.Url(url), isBinary });
+    private download(b: StateBuilder.To<PSO.Root>, url: string) {
+        return b.apply(StateTransforms.Data.Download, { url, isBinary: false })
     }
 
     private model(b: StateBuilder.To<PSO.Data.Binary | PSO.Data.String>, format: SupportedFormats) {
@@ -89,18 +92,10 @@ class MolStarProteopediaWrapper {
 
     private structure(assemblyId: string) {
         const model = this.state.build().to(StateElements.Model);
-        const props = {
-            type: assemblyId ? {
-                name: 'assembly' as const,
-                params: { id: assemblyId }
-            } : {
-                name: 'model' as const,
-                params: {}
-            }
-        };
 
         const s = model
-            .apply(StateTransforms.Model.StructureFromModel, props, { ref: StateElements.Assembly });
+            .apply(StateTransforms.Model.CustomModelProperties, { properties: [EvolutionaryConservation.Descriptor.name] }, { ref: StateElements.ModelProps, state: { isGhost: false } })
+            .apply(StateTransforms.Model.StructureAssemblyFromModel, { id: assemblyId || 'deposited' }, { ref: StateElements.Assembly });
 
         s.apply(StateTransforms.Model.StructureComplexElement, { type: 'atomic-sequence' }, { ref: StateElements.Sequence });
         s.apply(StateTransforms.Model.StructureComplexElement, { type: 'atomic-het' }, { ref: StateElements.Het });
@@ -113,7 +108,7 @@ class MolStarProteopediaWrapper {
         const structure = this.getObj<PluginStateObject.Molecule.Structure>(StateElements.Assembly);
         if (!structure) return;
 
-        const style = _style || {};
+        const style = _style || { };
 
         const update = this.state.build();
 
@@ -123,10 +118,9 @@ class MolStarProteopediaWrapper {
                 root.delete(StateElements.SequenceVisual);
             } else {
                 root.applyOrUpdate(StateElements.SequenceVisual, StateTransforms.Representation.StructureRepresentation3D,
-                    createStructureRepresentationParams(this.plugin, structure, {
-                        type: (style.sequence && style.sequence.kind) || 'cartoon',
-                        color: (style.sequence && style.sequence.coloring) || 'unit-index'
-                    }));
+                    StructureRepresentation3DHelpers.getDefaultParamsWithTheme(this.plugin,
+                        (style.sequence && style.sequence.kind) || 'cartoon',
+                        (style.sequence && style.sequence.coloring) || 'unit-index', structure));
             }
         }
 
@@ -139,10 +133,9 @@ class MolStarProteopediaWrapper {
                     root.delete(StateElements.HetVisual);
                 } else {
                     root.applyOrUpdate(StateElements.HetVisual, StateTransforms.Representation.StructureRepresentation3D,
-                        createStructureRepresentationParams(this.plugin, structure, {
-                            type: (style.hetGroups && style.hetGroups.kind) || 'ball-and-stick',
-                            color: style.hetGroups && style.hetGroups.coloring
-                        }));
+                        StructureRepresentation3DHelpers.getDefaultParamsWithTheme(this.plugin,
+                            (style.hetGroups && style.hetGroups.kind) || 'ball-and-stick',
+                            (style.hetGroups && style.hetGroups.coloring), structure));
                 }
             }
         }
@@ -156,7 +149,7 @@ class MolStarProteopediaWrapper {
                     root.delete(StateElements.Het3DSNFG);
                 } else {
                     root.applyOrUpdate(StateElements.Het3DSNFG, StateTransforms.Representation.StructureRepresentation3D,
-                        createStructureRepresentationParams(this.plugin, structure, { type: 'carbohydrate' }));
+                        StructureRepresentation3DHelpers.getDefaultParamsWithTheme(this.plugin, 'carbohydrate', void 0, structure));
                 }
             }
         }
@@ -167,11 +160,9 @@ class MolStarProteopediaWrapper {
                 root.delete(StateElements.WaterVisual);
             } else {
                 root.applyOrUpdate(StateElements.WaterVisual, StateTransforms.Representation.StructureRepresentation3D,
-                    createStructureRepresentationParams(this.plugin, structure, {
-                        type: (style.water && style.water.kind) || 'ball-and-stick',
-                        typeParams: { alpha: 0.51 },
-                        color: style.water && style.water.coloring
-                    }));
+                        StructureRepresentation3DHelpers.getDefaultParamsWithTheme(this.plugin,
+                            (style.water && style.water.kind) || 'ball-and-stick',
+                            (style.water && style.water.coloring), structure, { alpha: 0.51 }));
             }
         }
 
@@ -189,21 +180,20 @@ class MolStarProteopediaWrapper {
         const model = this.getObj<PluginStateObject.Molecule.Model>('model');
         if (!model) return;
 
-        const info = await ModelInfo.get(this.plugin, model, checkPreferredAssembly);
+        const info = await ModelInfo.get(this.plugin, model, checkPreferredAssembly)
         this.events.modelInfo.next(info);
         return info;
     }
 
     private applyState(tree: StateBuilder) {
-        return PluginCommands.State.Update(this.plugin, { state: this.plugin.state.data, tree });
+        return PluginCommands.State.Update.dispatch(this.plugin, { state: this.plugin.state.dataState, tree });
     }
 
-    private emptyLoadedParams: LoadParams = { url: '', format: 'cif', isBinary: false, assemblyId: '' };
-    private loadedParams: LoadParams = { url: '', format: 'cif', isBinary: false, assemblyId: '' };
-    async load({ url, format = 'cif', assemblyId = '', isBinary = false, representationStyle }: LoadParams) {
+    private loadedParams: LoadParams = { url: '', format: 'cif', assemblyId: '' };
+    async load({ url, format = 'cif', assemblyId = 'deposited', representationStyle }: LoadParams) {
         let loadType: 'full' | 'update' = 'full';
 
-        const state = this.plugin.state.data;
+        const state = this.plugin.state.dataState;
 
         if (this.loadedParams.url !== url || this.loadedParams.format !== format) {
             loadType = 'full';
@@ -212,8 +202,8 @@ class MolStarProteopediaWrapper {
         }
 
         if (loadType === 'full') {
-            await PluginCommands.State.RemoveObject(this.plugin, { state, ref: state.tree.root.ref });
-            const modelTree = this.model(this.download(state.build().toRoot(), url, isBinary), format);
+            await PluginCommands.State.RemoveObject.dispatch(this.plugin, { state, ref: state.tree.root.ref });
+            const modelTree = this.model(this.download(state.build().toRoot(), url), format);
             await this.applyState(modelTree);
             const info = await this.doInfo(true);
             const asmId = (assemblyId === 'preferred' && info && info.preferredAssemblyId) || assemblyId;
@@ -223,54 +213,37 @@ class MolStarProteopediaWrapper {
             const tree = state.build();
             const info = await this.doInfo(true);
             const asmId = (assemblyId === 'preferred' && info && info.preferredAssemblyId) || assemblyId;
-            const props = {
-                type: assemblyId ? {
-                    name: 'assembly' as const,
-                    params: { id: asmId }
-                } : {
-                    name: 'model' as const,
-                    params: {}
-                }
-            };
-            tree.to(StateElements.Assembly).update(StateTransforms.Model.StructureFromModel, p => ({ ...p, ...props }));
+            tree.to(StateElements.Assembly).update(StateTransforms.Model.StructureAssemblyFromModel, p => ({ ...p, id: asmId }));
             await this.applyState(tree);
         }
 
         await this.updateStyle(representationStyle);
 
         this.loadedParams = { url, format, assemblyId };
+        Scheduler.setImmediate(() => PluginCommands.Camera.Reset.dispatch(this.plugin, { }));
     }
 
     async updateStyle(style?: RepresentationStyle, partial?: boolean) {
         const tree = this.visual(style, partial);
         if (!tree) return;
-        await PluginCommands.State.Update(this.plugin, { state: this.plugin.state.data, tree });
+        await PluginCommands.State.Update.dispatch(this.plugin, { state: this.plugin.state.dataState, tree });
     }
 
     setBackground(color: number) {
-        if (!this.plugin.canvas3d) return;
         const renderer = this.plugin.canvas3d.props.renderer;
-        PluginCommands.Canvas3D.SetSettings(this.plugin, { settings: { renderer: { ...renderer, backgroundColor: Color(color) } } });
+        PluginCommands.Canvas3D.SetSettings.dispatch(this.plugin, { settings: { renderer: { ...renderer,  backgroundColor: Color(color) } } });
     }
 
     toggleSpin() {
-        if (!this.plugin.canvas3d) return;
         const trackball = this.plugin.canvas3d.props.trackball;
-        PluginCommands.Canvas3D.SetSettings(this.plugin, {
-            settings: {
-                trackball: {
-                    ...trackball,
-                    animate: trackball.animate.name === 'spin'
-                        ? { name: 'off', params: {} }
-                        : { name: 'spin', params: { speed: 1 } }
-                }
-            }
-        });
+        const spinning = trackball.spin;
+        PluginCommands.Canvas3D.SetSettings.dispatch(this.plugin, { settings: { trackball: { ...trackball, spin: !trackball.spin } } });
+        if (!spinning) PluginCommands.Camera.Reset.dispatch(this.plugin, { });
     }
 
     viewport = {
         setSettings: (settings?: Canvas3DProps) => {
-            PluginCommands.Canvas3D.SetSettings(this.plugin, {
+            PluginCommands.Canvas3D.SetSettings.dispatch(this.plugin, {
                 settings: settings || DefaultCanvas3DParams
             });
         }
@@ -278,23 +251,38 @@ class MolStarProteopediaWrapper {
 
     camera = {
         toggleSpin: () => this.toggleSpin(),
-        resetPosition: () => PluginCommands.Camera.Reset(this.plugin, {})
-    };
+        resetPosition: () => PluginCommands.Camera.Reset.dispatch(this.plugin, { }),
+        // setClip: (options?: { distance?: number, near?: number, far?: number }) => {
+        //     if (!options) {
+        //         PluginCommands.Canvas3D.SetSettings.dispatch(this.plugin, {
+        //             settings: {
+        //                 cameraClipDistance: DefaultCanvas3DParams.cameraClipDistance,
+        //                 clip: DefaultCanvas3DParams.clip
+        //             }
+        //         });
+        //         return;
+        //     }
 
-    private animateModelIndexTargetFps() {
-        return Math.max(1, this.animate.modelIndex.targetFps | 0);
+        //     options = options || { };
+        //     const props = this.plugin.canvas3d.props;
+        //     const clipNear = typeof options.near === 'undefined' ? props.clip[0] : options.near;
+        //     const clipFar = typeof options.far === 'undefined' ? props.clip[1] : options.far;
+        //     PluginCommands.Canvas3D.SetSettings.dispatch(this.plugin, {
+        //         settings: { cameraClipDistance: options.distance, clip: [clipNear, clipFar] }
+        //     });
+        // }
     }
 
     animate = {
         modelIndex: {
-            targetFps: 8,
-            onceForward: () => { this.plugin.managers.animation.play(AnimateModelIndex, { duration: { name: 'computed', params: { targetFps: this.animateModelIndexTargetFps() } }, mode: { name: 'once', params: { direction: 'forward' } } }); },
-            onceBackward: () => { this.plugin.managers.animation.play(AnimateModelIndex, { duration: { name: 'computed', params: { targetFps: this.animateModelIndexTargetFps() } }, mode: { name: 'once', params: { direction: 'backward' } } }); },
-            palindrome: () => { this.plugin.managers.animation.play(AnimateModelIndex, { duration: { name: 'computed', params: { targetFps: this.animateModelIndexTargetFps() } }, mode: { name: 'palindrome', params: {} } }); },
-            loop: () => { this.plugin.managers.animation.play(AnimateModelIndex, { duration: { name: 'computed', params: { targetFps: this.animateModelIndexTargetFps() } }, mode: { name: 'loop', params: { direction: 'forward' } } }); },
-            stop: () => this.plugin.managers.animation.stop()
+            maxFPS: 8,
+            onceForward: () => { this.plugin.state.animation.play(AnimateModelIndex, { maxFPS: Math.max(0.5, this.animate.modelIndex.maxFPS | 0), mode: { name: 'once', params: { direction: 'forward' } } }) },
+            onceBackward: () => { this.plugin.state.animation.play(AnimateModelIndex, { maxFPS: Math.max(0.5, this.animate.modelIndex.maxFPS | 0), mode: { name: 'once', params: { direction: 'backward' } } }) },
+            palindrome: () => { this.plugin.state.animation.play(AnimateModelIndex, { maxFPS: Math.max(0.5, this.animate.modelIndex.maxFPS | 0), mode: { name: 'palindrome', params: {} } }) },
+            loop: () => { this.plugin.state.animation.play(AnimateModelIndex, { maxFPS: Math.max(0.5, this.animate.modelIndex.maxFPS | 0), mode: { name: 'loop', params: {} } }) },
+            stop: () => this.plugin.state.animation.stop()
         }
-    };
+    }
 
     coloring = {
         evolutionaryConservation: async (params?: { sequence?: boolean, het?: boolean, keepStyle?: boolean }) => {
@@ -303,8 +291,13 @@ class MolStarProteopediaWrapper {
             }
 
             const state = this.state;
+
+            // const visuals = state.selectQ(q => q.ofType(PluginStateObject.Molecule.Structure.Representation3D).filter(c => c.transform.transformer === StateTransforms.Representation.StructureRepresentation3D));
+            // for (const v of visuals) {
+            // }
+
             const tree = state.build();
-            const colorTheme = { name: EvolutionaryConservation.propertyProvider.descriptor.name, params: this.plugin.representation.structure.themes.colorThemeRegistry.get(EvolutionaryConservation.propertyProvider.descriptor.name).defaultValues };
+            const colorTheme = { name: EvolutionaryConservation.Descriptor.name, params: this.plugin.structureRepresentation.themeCtx.colorThemeRegistry.get(EvolutionaryConservation.Descriptor.name).defaultValues };
 
             if (!params || !!params.sequence) {
                 tree.to(StateElements.SequenceVisual).update(StateTransforms.Representation.StructureRepresentation3D, old => ({ ...old, colorTheme }));
@@ -313,9 +306,9 @@ class MolStarProteopediaWrapper {
                 tree.to(StateElements.HetVisual).update(StateTransforms.Representation.StructureRepresentation3D, old => ({ ...old, colorTheme }));
             }
 
-            await PluginCommands.State.Update(this.plugin, { state, tree });
+            await PluginCommands.State.Update.dispatch(this.plugin, { state, tree });
         }
-    };
+    }
 
     private experimentalDataElement?: Element = void 0;
     experimentalData = {
@@ -333,23 +326,25 @@ class MolStarProteopediaWrapper {
         remove: () => {
             const r = this.state.select(StateSelection.Generators.ofTransformer(CreateVolumeStreamingInfo))[0];
             if (!r) return;
-            PluginCommands.State.RemoveObject(this.plugin, { state: this.state, ref: r.transform.ref });
+            PluginCommands.State.RemoveObject.dispatch(this.plugin, { state: this.state, ref: r.transform.ref });
             if (this.experimentalDataElement) {
                 ReactDOM.unmountComponentAtNode(this.experimentalDataElement);
                 this.experimentalDataElement = void 0;
             }
         }
-    };
+    }
 
     hetGroups = {
         reset: () => {
             const update = this.state.build().delete(StateElements.HetGroupFocusGroup);
-            PluginCommands.State.Update(this.plugin, { state: this.state, tree: update });
-            PluginCommands.Camera.Reset(this.plugin, {});
+            PluginCommands.State.Update.dispatch(this.plugin, { state: this.state, tree: update });
+            PluginCommands.Camera.Reset.dispatch(this.plugin, { });
         },
-        focusFirst: async (compId: string, options?: { hideLabels: boolean, doNotLabelWaters: boolean }) => {
+        focusFirst: async (compId: string) => {
             if (!this.state.transforms.has(StateElements.Assembly)) return;
-            await PluginCommands.Camera.Reset(this.plugin, {});
+            await PluginCommands.Camera.Reset.dispatch(this.plugin, { });
+
+            // const asm = (this.state.select(StateElements.Assembly)[0].obj as PluginStateObject.Molecule.Structure).data;
 
             const update = this.state.build();
 
@@ -364,72 +359,71 @@ class MolStarProteopediaWrapper {
             const surroundings = MS.struct.modifier.includeSurroundings({ 0: core, radius: 5, 'as-whole-residues': true });
 
             const group = update.to(StateElements.Assembly).group(StateTransforms.Misc.CreateGroup, { label: compId }, { ref: StateElements.HetGroupFocusGroup });
-            const asm = this.state.select(StateElements.Assembly)[0].obj as PluginStateObject.Molecule.Structure;
-            const coreSel = group.apply(StateTransforms.Model.StructureSelectionFromExpression, { label: 'Core', expression: core }, { ref: StateElements.HetGroupFocus });
-
-
-            coreSel.apply(StateTransforms.Representation.StructureRepresentation3D, createStructureRepresentationParams(this.plugin, asm.data, {
-                type: 'ball-and-stick'
-            }));
-            coreSel.apply(StateTransforms.Representation.StructureRepresentation3D, createStructureRepresentationParams(this.plugin, asm.data, {
-                type: 'label',
-                typeParams: { level: 'element' }
-            }), { tags: ['proteopedia-labels'] });
 
+            group.apply(StateTransforms.Model.StructureSelectionFromExpression, { label: 'Core', expression: core }, { ref: StateElements.HetGroupFocus })
+                .apply(StateTransforms.Representation.StructureRepresentation3D, this.createCoreVisualParams());
             group.apply(StateTransforms.Model.StructureSelectionFromExpression, { label: 'Surroundings', expression: surroundings })
-                .apply(StateTransforms.Representation.StructureRepresentation3D, createStructureRepresentationParams(this.plugin, asm.data, {
-                    type: 'ball-and-stick',
-                    color: 'uniform', colorParams: { value: ColorNames.gray },
-                    size: 'uniform', sizeParams: { value: 0.33 }
-                }));
+                .apply(StateTransforms.Representation.StructureRepresentation3D, this.createSurVisualParams());
+            // sel.apply(StateTransforms.Representation.StructureLabels3D, {
+            //     target: { name: 'residues', params: { } },
+            //     options: {
+            //         ...ParamDefinition.getDefaultValues(Text.Params),
+            //         background: true,
+            //         backgroundMargin: 0.2,
+            //         backgroundColor: ColorNames.snow,
+            //         backgroundOpacity: 0.9,
+            //     }
+            // });
 
-            if (!options?.hideLabels) {
-                // Labels
-                const waters = MS.struct.generator.atomGroups({
-                    'entity-test': MS.core.rel.eq([MS.struct.atomProperty.macromolecular.entityType(), 'water']),
-                });
-                const exclude = options?.doNotLabelWaters ? MS.struct.combinator.merge([core, waters]) : core;
-                const onlySurroundings = MS.struct.modifier.exceptBy({ 0: surroundings, by: exclude });
-
-                group.apply(StateTransforms.Model.StructureSelectionFromExpression, { label: 'Surroundings (only)', expression: onlySurroundings })
-                    .apply(StateTransforms.Representation.StructureRepresentation3D, createStructureRepresentationParams(this.plugin, asm.data, {
-                        type: 'label',
-                        typeParams: { level: 'residue' }
-                    }), { tags: ['proteopedia-labels'] }); // the tag can later be used to toggle the labels
-            }
-
-            await PluginCommands.State.Update(this.plugin, { state: this.state, tree: update });
+            await PluginCommands.State.Update.dispatch(this.plugin, { state: this.state, tree: update });
 
             const focus = (this.state.select(StateElements.HetGroupFocus)[0].obj as PluginStateObject.Molecule.Structure).data;
             const sphere = focus.boundary.sphere;
-            const radius = Math.max(sphere.radius, 5);
-            const snapshot = this.plugin.canvas3d!.camera.getFocus(sphere.center, radius);
-            PluginCommands.Camera.SetSnapshot(this.plugin, { snapshot, durationMs: 250 });
+            // const asmCenter = asm.boundary.sphere.center;
+            // const position = Vec3.sub(Vec3.zero(), sphere.center, asmCenter);
+            // Vec3.normalize(position, position);
+            // Vec3.scaleAndAdd(position, sphere.center, position, sphere.radius);
+            const snapshot = this.plugin.canvas3d.camera.getFocus(sphere.center, Math.max(sphere.radius, 5));
+            PluginCommands.Camera.SetSnapshot.dispatch(this.plugin, { snapshot, durationMs: 250 });
         }
-    };
+    }
+
+    private createSurVisualParams() {
+        const asm = this.state.select(StateElements.Assembly)[0].obj as PluginStateObject.Molecule.Structure;
+        return StructureRepresentation3DHelpers.createParams(this.plugin, asm.data, {
+            repr: BuiltInStructureRepresentations['ball-and-stick'],
+            color: [BuiltInColorThemes.uniform, () => ({ value: ColorNames.gray })],
+            size: [BuiltInSizeThemes.uniform, () => ({ value: 0.33 } )]
+        });
+    }
+
+    private createCoreVisualParams() {
+        const asm = this.state.select(StateElements.Assembly)[0].obj as PluginStateObject.Molecule.Structure;
+        return StructureRepresentation3DHelpers.createParams(this.plugin, asm.data, {
+            repr: BuiltInStructureRepresentations['ball-and-stick'],
+            // color: [BuiltInColorThemes.uniform, () => ({ value: ColorNames.gray })],
+            // size: [BuiltInSizeThemes.uniform, () => ({ value: 0.33 } )]
+        });
+    }
 
     snapshot = {
-        get: (params?: PluginState.SnapshotParams) => {
-            return this.plugin.state.getSnapshot(params);
+        get: () => {
+            return this.plugin.state.getSnapshot();
         },
         set: (snapshot: PluginState.Snapshot) => {
             return this.plugin.state.setSnapshot(snapshot);
         },
-        download: async (type: 'molj' | 'molx' = 'molj', params?: PluginState.SnapshotParams) => {
-            const data = await this.plugin.managers.snapshot.serialize({ type, params });
-            download(data, `mol-star_state_${getFormattedTime()}.${type}`);
-        },
-        fetch: async (url: string, type: 'molj' | 'molx' = 'molj') => {
+        download: async (url: string) => {
             try {
-                const data = await this.plugin.runTask(this.plugin.fetch({ url, type: 'binary' }));
-                this.loadedParams = { ...this.emptyLoadedParams };
-                return await this.plugin.managers.snapshot.open(new File([data], `state.${type}`));
+                const data = await this.plugin.runTask(this.plugin.fetch({ url }));
+                const snapshot = JSON.parse(data);
+                await this.plugin.state.setSnapshot(snapshot);
             } catch (e) {
                 console.log(e);
             }
         }
 
-    };
+    }
 }
 
 (window as any).MolStarProteopediaWrapper = MolStarProteopediaWrapper;

src/examples/proteopedia-wrapper/ui/controls.tsx

@@ -4,14 +4,29 @@
  * @author David Sehnal <david.sehnal@gmail.com>
  */
 
+import * as React from 'react';
 import * as ReactDOM from 'react-dom';
-import { PluginUIContext } from '../../../mol-plugin-ui/context';
-import { PluginContextContainer } from '../../../mol-plugin-ui/plugin';
-import { TransformUpdaterControl } from '../../../mol-plugin-ui/state/update-transform';
+import { PluginUIComponent } from '../../../mol-plugin/ui/base';
+import { CurrentObject, PluginContextContainer } from '../../../mol-plugin/ui/plugin';
+import { AnimationControls } from '../../../mol-plugin/ui/state/animation';
+import { CameraSnapshots } from '../../../mol-plugin/ui/camera';
+import { PluginContext } from '../../../mol-plugin/context';
+import { TransformUpdaterControl } from '../../../mol-plugin/ui/state/update-transform';
 import { StateElements } from '../helpers';
 
-export function volumeStreamingControls(plugin: PluginUIContext, parent: Element) {
+export class ControlsWrapper extends PluginUIComponent {
+    render() {
+        return <div className='msp-scrollable-container msp-right-controls'>
+            <CurrentObject />
+            <AnimationControls />
+            <CameraSnapshots />
+        </div>;
+    }
+}
+
+export function volumeStreamingControls(plugin: PluginContext, parent: Element) {
     ReactDOM.render(<PluginContextContainer plugin={plugin}>
-        <TransformUpdaterControl nodeRef={StateElements.VolumeStreaming} />
-    </PluginContextContainer>, parent);
+            <TransformUpdaterControl nodeRef={StateElements.VolumeStreaming} />
+        </PluginContextContainer>,
+        parent);
 }

src/examples/task.ts

@@ -4,7 +4,7 @@
  * @author David Sehnal <david.sehnal@gmail.com>
  */
 
-import { Task, Progress, Scheduler, MultistepTask, chunkedSubtask } from '../mol-task';
+import { Task, Progress, Scheduler, MultistepTask, chunkedSubtask } from '../mol-task'
 import { now } from '../mol-util/now';
 
 export async function test1() {
@@ -85,19 +85,19 @@ export const ms = MultistepTask('ms-task', ['step 1', 'step 2', 'step 3'], async
     await step(0);
 
     const child = Task.create('chunked', async ctx => {
-        const s = await chunkedSubtask(ctx, 25, { i: 0, current: 0, total: 125 }, processChunk, (ctx, s, p) => ctx.update('chunk test ' + p));
+        const s = await chunkedSubtask(ctx, 25, { i: 0, current: 0, total: 125 }, processChunk, (ctx, s, p) => ctx.update('chunk test ' + p))
         return s.i;
     });
 
     await child.runAsChild(ctx);
     await Scheduler.delay(250);
     await step(1);
-    await chunkedSubtask(ctx, 25, { i: 0, current: 0, total: 80 }, processChunk, (ctx, s, p) => ctx.update('chunk test ' + p));
+    await chunkedSubtask(ctx, 25, { i: 0, current: 0, total: 80 }, processChunk, (ctx, s, p) => ctx.update('chunk test ' + p))
     await Scheduler.delay(250);
     await step(2);
     await Scheduler.delay(250);
     return p.i + 3;
-});
+})
 
 
 export function abortingObserver(p: Progress) {

src/extensions/alpha-orbitals/_spec/collocation.spec.ts

@@ -1,214 +0,0 @@
-/**
- * Copyright (c) 2020 mol* contributors, licensed under MIT, See LICENSE file for more info.
- *
- * @author David Sehnal <david.sehnal@gmail.com>
- */
-
-import { Box3D } from '../../../mol-math/geometry';
-import { Vec3 } from '../../../mol-math/linear-algebra';
-import { RuntimeContext } from '../../../mol-task';
-import { sphericalCollocation } from '../collocation';
-import { Basis, CubeGridInfo } from '../data-model';
-
-describe('alpha-orbitals-cubes', () => {
-    it('water', async () => {
-        const grid: CubeGridInfo = {
-            params: {
-                basis: _testBasis,
-                cutoffThreshold: 0,
-                sphericalOrder: 'cca-reverse',
-                boxExpand: 0,
-                gridSpacing: []
-            },
-            box: Box3D.create(Vec3.create(-1, -1, -1), Vec3.create(1, 1, 1)),
-            delta: Vec3.create(2, 2, 2),
-            dimensions: Vec3.create(2, 2, 2),
-            npoints: 8,
-            size: Vec3.create(2, 2, 2)
-        };
-
-        const matrix = await sphericalCollocation(grid, {
-            energy: 0,
-            occupancy: 0,
-            alpha: [-2.2623991420609075e-16, 0.6360205395000592, 0.6672122399886391, -0.3876927909355508, -1.6780131293332933e-16, 2.844782862661151e-16, 4.977960694176068e-19, -2.3945919908996803e-16]
-        }, RuntimeContext.Synchronous);
-
-        const expected = [-0.1451730622877498, 0.06479453956039086, -0.2777738736440713, -0.057116584776260436, 0.05929916178822645, 0.2742903371231049, -0.07221698722165386, 0.15389180241391376];
-
-        expect(matrix.length).toBe(expected.length);
-
-        for (let i = 0; i < matrix.length; i++) {
-            expect(Math.abs(matrix[i] - expected[i]) < 1e-6).toBe(true);
-        }
-    });
-});
-
-const _testBasis: Basis = {
-    'atoms': [
-        {
-            'center': [
-                0.025886090588624934,
-                0.019164790004065606,
-                -0.013539970104105408
-            ] as Vec3,
-            'shells': [
-                {
-                    'angularMomentum': [0],
-                    'coefficients': [
-                        [
-                            -0.004151277818987536,
-                            -0.02067024147993795,
-                            -0.05150303336984537,
-                            0.33462711739899537,
-                            0.5621061300983125,
-                            0.17129946969948573
-                        ]
-                    ],
-                    'exponents': [
-                        152.28769660788095,
-                        27.928015215973073,
-                        7.848374792384515,
-                        1.1223350202705642,
-                        0.5093846587907856,
-                        0.24292266532510307
-                    ]
-                },
-                {
-                    'angularMomentum': [1],
-                    'coefficients': [
-                        [
-                            0.007924233646294425,
-                            0.051441048251911314,
-                            0.18984000600705359,
-                            0.4049863191150474,
-                            0.40123628611490797,
-                            0.1051855189039082
-                        ]
-                    ],
-                    'exponents': [
-                        27.203421487167727,
-                        7.09409912597673,
-                        2.5383362605345954,
-                        1.0610730767843852,
-                        0.4851948916410433,
-                        0.22938302550642545
-                    ]
-                }
-            ]
-        },
-        {
-            'center': [
-                0.5082729578468134,
-                1.6880351220025265,
-                0.4963443067810461
-            ] as Vec3,
-            'shells': [
-                {
-                    'angularMomentum': [0],
-                    'coefficients': [
-                        [
-                            0.009163596280542963,
-                            0.04936149294292479,
-                            0.16853830490998634,
-                            0.37056279972195677,
-                            0.4164915298246781,
-                            0.13033408410772263
-                        ]
-                    ],
-                    'exponents': [
-                        33.710073211949485,
-                        6.180705022740464,
-                        1.7291385346152253,
-                        0.5940057549921978,
-                        0.2306698170449518,
-                        0.09500256906284119
-                    ]
-                },
-                {
-                    'angularMomentum': [0],
-                    'coefficients': [
-                        [
-                            -0.32279868167000036,
-                            3.209629817295221,
-                            2.4672629224617935,
-                            -0.048487066612842224,
-                            -0.2611850111200143,
-                            -0.8917817597810863,
-                            -1.9607480081275706,
-                            -2.203769342520311,
-                            -0.6896328935259993
-                        ]
-                    ],
-                    'exponents': [
-                        10.256286070314905,
-                        0.6227965325875392,
-                        0.2391007667853915,
-                        33.710073211949485,
-                        6.180705022740464,
-                        1.7291385346152253,
-                        0.5940057549921978,
-                        0.2306698170449518,
-                        0.09500256906284119
-                    ]
-                }
-            ]
-        },
-        {
-            'center': [
-                1.1367367844436005,
-                -0.47018519422670163,
-                -1.356802622574504
-            ] as Vec3,
-            'shells': [
-                {
-                    'angularMomentum': [0],
-                    'coefficients': [
-                        [
-                            0.009163596280542963,
-                            0.04936149294292479,
-                            0.16853830490998634,
-                            0.37056279972195677,
-                            0.4164915298246781,
-                            0.13033408410772263
-                        ]
-                    ],
-                    'exponents': [
-                        33.710073211949485,
-                        6.180705022740464,
-                        1.7291385346152253,
-                        0.5940057549921978,
-                        0.2306698170449518,
-                        0.09500256906284119
-                    ]
-                },
-                {
-                    'angularMomentum': [0],
-                    'coefficients': [
-                        [
-                            -0.32279868167000036,
-                            3.209629817295221,
-                            2.4672629224617935,
-                            -0.048487066612842224,
-                            -0.2611850111200143,
-                            -0.8917817597810863,
-                            -1.9607480081275706,
-                            -2.203769342520311,
-                            -0.6896328935259993
-                        ]
-                    ],
-                    'exponents': [
-                        10.256286070314905,
-                        0.6227965325875392,
-                        0.2391007667853915,
-                        33.710073211949485,
-                        6.180705022740464,
-                        1.7291385346152253,
-                        0.5940057549921978,
-                        0.2306698170449518,
-                        0.09500256906284119
-                    ]
-                }
-            ]
-        }
-    ]
-};

src/extensions/alpha-orbitals/collocation.ts

@@ -1,162 +0,0 @@
-/**
- * Copyright (c) 2020 mol* contributors, licensed under MIT, See LICENSE file for more info.
- *
- * Inspired by https://github.com/dgasmith/gau2grid.
- *
- * @author David Sehnal <david.sehnal@gmail.com>
- */
-
-import { Vec3 } from '../../mol-math/linear-algebra';
-import { RuntimeContext } from '../../mol-task';
-import { arrayMin } from '../../mol-util/array';
-import { AlphaOrbital, CubeGridInfo } from './data-model';
-import { normalizeBasicOrder, SphericalFunctions } from './spherical-functions';
-
-export async function sphericalCollocation(
-    grid: CubeGridInfo,
-    orbital: AlphaOrbital,
-    taskCtx: RuntimeContext
-) {
-    const { basis, sphericalOrder, cutoffThreshold } = grid.params;
-    let baseCount = 0;
-
-    for (const atom of basis.atoms) {
-        for (const shell of atom.shells) {
-            for (const L of shell.angularMomentum) {
-                if (L > 4) {
-                    // TODO: will L > 4 be required? Would need to precompute more functions in that case.
-                    throw new Error('Angular momentum L > 4 not supported.');
-                }
-
-                baseCount += 2 * L + 1;
-            }
-        }
-    }
-
-    const matrix = new Float32Array(grid.npoints);
-
-    let baseIndex = 0;
-    for (const atom of basis.atoms) {
-        for (const shell of atom.shells) {
-            let amIndex = 0;
-            for (const L of shell.angularMomentum) {
-                const alpha = normalizeBasicOrder(
-                    L,
-                    orbital.alpha.slice(baseIndex, baseIndex + 2 * L + 1),
-                    sphericalOrder
-                );
-                baseIndex += 2 * L + 1;
-
-                collocationBasis(
-                    matrix,
-                    grid,
-                    L,
-                    shell.coefficients[amIndex++],
-                    shell.exponents,
-                    atom.center,
-                    cutoffThreshold,
-                    alpha
-                );
-
-                if (taskCtx.shouldUpdate) {
-                    await taskCtx.update({
-                        message: 'Computing...',
-                        current: baseIndex,
-                        max: baseCount,
-                        isIndeterminate: false,
-                    });
-                }
-            }
-        }
-    }
-
-    return matrix;
-}
-
-function collocationBasis(
-    matrix: Float32Array,
-    grid: CubeGridInfo,
-    L: number,
-    coefficients: number[],
-    exponents: number[],
-    center: Vec3,
-    cutoffThreshold: number,
-    alpha: number[]
-) {
-    const ncoeff = exponents.length;
-    const sphericalFunc = SphericalFunctions[L];
-
-    const cx = center[0],
-        cy = center[1],
-        cz = center[2];
-    const ny = grid.dimensions[1],
-        nz = grid.dimensions[2];
-    const gdx = grid.delta[0],
-        gdy = grid.delta[1],
-        gdz = grid.delta[2];
-    const sx = grid.box.min[0],
-        sy = grid.box.min[1],
-        sz = grid.box.min[2];
-
-    const cutoffRadius =
-        cutoffThreshold > 0
-            ? Math.sqrt(-Math.log(cutoffThreshold) / arrayMin(exponents))
-            : 10000;
-    const cutoffSquared = cutoffRadius * cutoffRadius;
-
-    const radiusBox = getRadiusBox(grid, center, cutoffRadius);
-    const iMin = radiusBox[0][0],
-        jMin = radiusBox[0][1],
-        kMin = radiusBox[0][2];
-    const iMax = radiusBox[1][0],
-        jMax = radiusBox[1][1],
-        kMax = radiusBox[1][2];
-
-    for (let i = iMin; i <= iMax; i++) {
-        const x = sx + gdx * i - cx;
-        const oX = i * ny * nz;
-
-        for (let j = jMin; j <= jMax; j++) {
-            const y = sy + gdy * j - cy;
-            const oY = oX + j * nz;
-            for (let k = kMin; k <= kMax; k++) {
-                const z = sz + gdz * k - cz;
-                const R2 = x * x + y * y + z * z;
-
-                if (R2 > cutoffSquared) {
-                    continue;
-                }
-
-                let gaussianSum = 0;
-                for (let c = 0; c < ncoeff; c++) {
-                    gaussianSum +=
-                        coefficients[c] * Math.exp(-exponents[c] * R2);
-                }
-
-                const sphericalSum = L === 0 ? alpha[0] : sphericalFunc(alpha, x, y, z);
-
-
-                matrix[k + oY] += gaussianSum * sphericalSum;
-            }
-        }
-    }
-}
-
-function getRadiusBox(grid: CubeGridInfo, center: Vec3, radius: number) {
-    const r = Vec3.create(radius, radius, radius);
-    const min = Vec3.scaleAndAdd(Vec3(), center, r, -1);
-    const max = Vec3.add(Vec3(), center, r);
-
-    Vec3.sub(min, min, grid.box.min);
-    Vec3.sub(max, max, grid.box.min);
-
-    Vec3.div(min, min, grid.delta);
-    Vec3.floor(min, min);
-    Vec3.max(min, min, Vec3());
-
-    Vec3.div(max, max, grid.delta);
-    Vec3.ceil(max, max);
-    Vec3.min(max, max, Vec3.subScalar(Vec3(), grid.dimensions, 1));
-
-    return [min, max];
-}

src/extensions/alpha-orbitals/data-model.ts

@@ -1,143 +0,0 @@
-/**
- * Copyright (c) 2020 mol* contributors, licensed under MIT, See LICENSE file for more info.
- *
- * @author David Sehnal <david.sehnal@gmail.com>
- */
-
-import { Mat4, Tensor, Vec3 } from '../../mol-math/linear-algebra';
-import { Grid } from '../../mol-model/volume';
-import { SphericalBasisOrder } from './spherical-functions';
-import { Box3D, RegularGrid3d } from '../../mol-math/geometry';
-import { arrayMin, arrayMax, arrayRms, arrayMean } from '../../mol-util/array';
-import { ModelFormat } from '../../mol-model-formats/format';
-
-// Note: generally contracted gaussians are currently not supported.
-export interface SphericalElectronShell {
-    exponents: number[];
-    angularMomentum: number[];
-    // number[] for each angular momentum
-    coefficients: number[][];
-}
-
-export interface Basis {
-    atoms: {
-        // in Bohr units!
-        center: Vec3;
-        shells: SphericalElectronShell[];
-    }[];
-}
-
-export interface AlphaOrbital {
-    energy: number;
-    occupancy: number;
-    alpha: number[];
-}
-
-export interface CubeGridComputationParams {
-    basis: Basis;
-    /**
-     * for each electron shell compute a cutoff radius as
-     *    const cutoffRadius = Math.sqrt(-Math.log(cutoffThreshold) / arrayMin(exponents));
-     */
-    cutoffThreshold: number;
-    sphericalOrder: SphericalBasisOrder;
-    boxExpand: number;
-    gridSpacing: number | [atomCountThreshold: number, spacing: number][];
-    doNotComputeIsovalues?: boolean;
-}
-
-export interface CubeGridInfo {
-    params: CubeGridComputationParams;
-    dimensions: Vec3;
-    box: Box3D;
-    size: Vec3;
-    npoints: number;
-    delta: Vec3;
-}
-
-export interface CubeGrid {
-    grid: Grid;
-    isovalues?: { negative?: number; positive?: number };
-}
-
-export type CubeGridFormat = ModelFormat<CubeGrid>;
-
-// eslint-disable-next-line
-export function CubeGridFormat(grid: CubeGrid): CubeGridFormat {
-    return { name: 'custom grid', kind: 'cube-grid', data: grid };
-}
-
-export function isCubeGridData(f: ModelFormat): f is CubeGridFormat {
-    return f.kind === 'cube-grid';
-}
-
-export function initCubeGrid(params: CubeGridComputationParams): CubeGridInfo {
-    const geometry = params.basis.atoms.map(a => a.center);
-    const { gridSpacing: spacing, boxExpand: expand } = params;
-
-    const count = geometry.length;
-    const box = Box3D.expand(
-        Box3D(),
-        Box3D.fromVec3Array(Box3D(), geometry),
-        Vec3.create(expand, expand, expand)
-    );
-    const size = Box3D.size(Vec3(), box);
-
-    const spacingThresholds =
-        typeof spacing === 'number' ? [[0, spacing]] : [...spacing];
-    spacingThresholds.sort((a, b) => b[0] - a[0]);
-
-    let s = 0.4;
-    for (let i = 0; i <= spacingThresholds.length; i++) {
-        s = spacingThresholds[i][1];
-        if (spacingThresholds[i][0] <= count) break;
-    }
-
-    const dimensions = Vec3.ceil(Vec3(), Vec3.scale(Vec3(), size, 1 / s));
-
-    return {
-        params,
-        box,
-        dimensions,
-        size,
-        npoints: dimensions[0] * dimensions[1] * dimensions[2],
-        delta: Vec3.div(Vec3(), size, Vec3.subScalar(Vec3(), dimensions, 1)),
-    };
-}
-
-const BohrToAngstromFactor = 0.529177210859;
-
-export function createGrid(gridInfo: RegularGrid3d, values: Float32Array, axisOrder: number[]) {
-    const boxSize = Box3D.size(Vec3(), gridInfo.box);
-    const boxOrigin = Vec3.clone(gridInfo.box.min);
-
-    Vec3.scale(boxSize, boxSize, BohrToAngstromFactor);
-    Vec3.scale(boxOrigin, boxOrigin, BohrToAngstromFactor);
-
-    const scale = Mat4.fromScaling(
-        Mat4(),
-        Vec3.div(
-            Vec3(),
-            boxSize,
-            Vec3.sub(Vec3(), gridInfo.dimensions, Vec3.create(1, 1, 1))
-        )
-    );
-    const translate = Mat4.fromTranslation(Mat4(), boxOrigin);
-    const matrix = Mat4.mul(Mat4(), translate, scale);
-
-    const grid: Grid = {
-        transform: { kind: 'matrix', matrix },
-        cells: Tensor.create(
-            Tensor.Space(gridInfo.dimensions, axisOrder, Float32Array),
-            (values as any) as Tensor.Data
-        ),
-        stats: {
-            min: arrayMin(values),
-            max: arrayMax(values),
-            mean: arrayMean(values),
-            sigma: arrayRms(values),
-        },
-    };
-
-    return grid;
-}

src/extensions/alpha-orbitals/density.ts

@@ -1,125 +0,0 @@
-/**
- * Copyright (c) 2020-2022 mol* contributors, licensed under MIT, See LICENSE file for more info.
- *
- * @author David Sehnal <david.sehnal@gmail.com>
- */
-
-import { sortArray } from '../../mol-data/util';
-import { canComputeGrid3dOnGPU } from '../../mol-gl/compute/grid3d';
-import { WebGLContext } from '../../mol-gl/webgl/context';
-import { Task } from '../../mol-task';
-import { isTimingMode } from '../../mol-util/debug';
-import { AlphaOrbital, createGrid, CubeGrid, CubeGridComputationParams, initCubeGrid } from './data-model';
-import { gpuComputeAlphaOrbitalsDensityGridValues } from './gpu/compute';
-
-export function createSphericalCollocationDensityGrid(
-    params: CubeGridComputationParams, orbitals: AlphaOrbital[], webgl?: WebGLContext
-): Task<CubeGrid> {
-    return Task.create('Spherical Collocation Grid', async (ctx) => {
-        const cubeGrid = initCubeGrid(params);
-
-        let matrix: Float32Array;
-        if (canComputeGrid3dOnGPU(webgl)) {
-            if (isTimingMode) webgl.timer.mark('createSphericalCollocationDensityGrid');
-            matrix = await gpuComputeAlphaOrbitalsDensityGridValues(ctx, webgl, cubeGrid, orbitals);
-            if (isTimingMode) webgl.timer.markEnd('createSphericalCollocationDensityGrid');
-        } else {
-            throw new Error('Missing OES_texture_float WebGL extension.');
-        }
-
-        const grid = createGrid(cubeGrid, matrix, [0, 1, 2]);
-        let isovalues: { negative?: number, positive?: number } | undefined;
-
-        if (!params.doNotComputeIsovalues) {
-            isovalues = computeDensityIsocontourValues(matrix, 0.85);
-        }
-
-        return { grid, isovalues };
-    });
-}
-
-export function computeDensityIsocontourValues(input: Float32Array, cumulativeThreshold: number) {
-    let weightSum = 0;
-    for (let i = 0, _i = input.length; i < _i; i++) {
-        const v = input[i];
-        const w = Math.abs(v);
-        weightSum += w;
-    }
-    const avgWeight = weightSum / input.length;
-    let minWeight = 3 * avgWeight;
-
-    // do not try to identify isovalues for degenerate data
-    // e.g. all values are almost same
-    if (Math.abs(avgWeight - input[0] * input[0]) < 1e-5) {
-        return { negative: void 0, positive: void 0 };
-    }
-
-    let size = 0;
-    while (true) {
-        let csum = 0;
-        size = 0;
-        for (let i = 0, _i = input.length; i < _i; i++) {
-            const v = input[i];
-            const w = Math.abs(v);
-            if (w >= minWeight) {
-                csum += w;
-                size++;
-            }
-        }
-
-        if (csum / weightSum > cumulativeThreshold) {
-            break;
-        }
-
-        minWeight -= avgWeight;
-    }
-
-    const values = new Float32Array(size);
-    const weights = new Float32Array(size);
-    const indices = new Int32Array(size);
-
-    let o = 0;
-    for (let i = 0, _i = input.length; i < _i; i++) {
-        const v = input[i];
-        const w = Math.abs(v);
-        if (w >= minWeight) {
-            values[o] = v;
-            weights[o] = w;
-            indices[o] = o;
-            o++;
-        }
-    }
-
-    sortArray(
-        indices,
-        (indices, i, j) => weights[indices[j]] - weights[indices[i]]
-    );
-
-    let cweight = 0,
-        cutoffIndex = 0;
-    for (let i = 0; i < size; i++) {
-        cweight += weights[indices[i]];
-
-        if (cweight / weightSum >= cumulativeThreshold) {
-            cutoffIndex = i;
-            break;
-        }
-    }
-
-    let positive = Number.POSITIVE_INFINITY,
-        negative = Number.NEGATIVE_INFINITY;
-
-    for (let i = 0; i < cutoffIndex; i++) {
-        const v = values[indices[i]];
-        if (v > 0) {
-            if (v < positive) positive = v;
-        } else if (v < 0) {
-            if (v > negative) negative = v;
-        }
-    }
-
-    return {
-        negative: negative !== Number.NEGATIVE_INFINITY ? negative : void 0,
-        positive: positive !== Number.POSITIVE_INFINITY ? positive : void 0,
-    };
-}

src/extensions/alpha-orbitals/gpu/compute.ts

@@ -1,170 +0,0 @@
-/**
- * Copyright (c) 2020 mol* contributors, licensed under MIT, See LICENSE file for more info.
- *
- * @author David Sehnal <david.sehnal@gmail.com>
- */
-
-import { createGrid3dComputeRenderable } from '../../../mol-gl/compute/grid3d';
-import { TextureSpec, UnboxedValues, UniformSpec } from '../../../mol-gl/renderable/schema';
-import { WebGLContext } from '../../../mol-gl/webgl/context';
-import { RuntimeContext } from '../../../mol-task';
-import { ValueCell } from '../../../mol-util';
-import { arrayMin } from '../../../mol-util/array';
-import { AlphaOrbital, Basis, CubeGridInfo } from '../data-model';
-import { normalizeBasicOrder, SphericalBasisOrder } from '../spherical-functions';
-import { MAIN, UTILS } from './shader.frag';
-
-const Schema = {
-    tCenters: TextureSpec('image-float32', 'rgba', 'float', 'nearest'),
-    tInfo: TextureSpec('image-float32', 'rgba', 'float', 'nearest'),
-    tCoeff: TextureSpec('image-float32', 'rgb', 'float', 'nearest'),
-    tAlpha: TextureSpec('image-float32', 'alpha', 'float', 'nearest'),
-    uNCenters: UniformSpec('i'),
-    uNAlpha: UniformSpec('i'),
-    uNCoeff: UniformSpec('i'),
-    uMaxCoeffs: UniformSpec('i'),
-};
-
-const Orbitals = createGrid3dComputeRenderable({
-    schema: Schema,
-    loopBounds: ['uNCenters', 'uMaxCoeffs'],
-    mainCode: MAIN,
-    utilCode: UTILS,
-    returnCode: 'v',
-    values(params: { grid: CubeGridInfo, orbital: AlphaOrbital }) {
-        return createTextureData(params.grid, params.orbital);
-    }
-});
-
-const Density = createGrid3dComputeRenderable({
-    schema: {
-        ...Schema,
-        uOccupancy: UniformSpec('f'),
-    },
-    loopBounds: ['uNCenters', 'uMaxCoeffs'],
-    mainCode: MAIN,
-    utilCode: UTILS,
-    returnCode: 'current + uOccupancy * v * v',
-    values(params: { grid: CubeGridInfo, orbitals: AlphaOrbital[] }) {
-        return {
-            ...createTextureData(params.grid, params.orbitals[0]),
-            uOccupancy: 0
-        };
-    },
-    cumulative: {
-        states(params: { grid: CubeGridInfo, orbitals: AlphaOrbital[] }) {
-            return params.orbitals.filter(o => o.occupancy !== 0);
-        },
-        update({ grid }, state: AlphaOrbital, values) {
-            const alpha = getNormalizedAlpha(grid.params.basis, state.alpha, grid.params.sphericalOrder);
-            ValueCell.updateIfChanged(values.uOccupancy, state.occupancy);
-            ValueCell.update(values.tAlpha, { width: alpha.length, height: 1, array: alpha });
-        }
-    }
-});
-
-export function gpuComputeAlphaOrbitalsGridValues(ctx: RuntimeContext, webgl: WebGLContext, grid: CubeGridInfo, orbital: AlphaOrbital) {
-    return Orbitals(ctx, webgl, grid, { grid, orbital });
-}
-
-export function gpuComputeAlphaOrbitalsDensityGridValues(ctx: RuntimeContext, webgl: WebGLContext, grid: CubeGridInfo, orbitals: AlphaOrbital[]) {
-    return Density(ctx, webgl, grid, { grid, orbitals });
-}
-
-function getNormalizedAlpha(basis: Basis, alphaOrbitals: number[], sphericalOrder: SphericalBasisOrder) {
-    const alpha = new Float32Array(alphaOrbitals.length);
-
-    let aO = 0;
-    for (const atom of basis.atoms) {
-        for (const shell of atom.shells) {
-            for (const L of shell.angularMomentum) {
-                const a0 = normalizeBasicOrder(L, alphaOrbitals.slice(aO, aO + 2 * L + 1), sphericalOrder);
-                for (let i = 0; i < a0.length; i++) alpha[aO + i] = a0[i];
-                aO += 2 * L + 1;
-            }
-        }
-    }
-
-    return alpha;
-}
-
-function createTextureData(grid: CubeGridInfo, orbital: AlphaOrbital): UnboxedValues<typeof Schema> {
-    const { basis, sphericalOrder, cutoffThreshold } = grid.params;
-
-    let centerCount = 0;
-    let baseCount = 0;
-    let coeffCount = 0;
-    for (const atom of basis.atoms) {
-        for (const shell of atom.shells) {
-            for (const L of shell.angularMomentum) {
-                if (L > 4) {
-                    // TODO: will L > 4 be required? Would need to precompute more functions in that case.
-                    throw new Error('Angular momentum L > 4 not supported.');
-                }
-
-                centerCount++;
-                baseCount += 2 * L + 1;
-                coeffCount += shell.exponents.length;
-            }
-        }
-    }
-
-    const centers = new Float32Array(4 * centerCount);
-    // L, alpha_offset, coeff_offset_start, coeff_offset_end
-    const info = new Float32Array(4 * centerCount);
-    const alpha = new Float32Array(baseCount);
-    const coeff = new Float32Array(3 * coeffCount);
-
-    let maxCoeffs = 0;
-    let cO = 0, aO = 0, coeffO = 0;
-    for (const atom of basis.atoms) {
-        for (const shell of atom.shells) {
-
-            let amIndex = 0;
-            for (const L of shell.angularMomentum) {
-                const a0 = normalizeBasicOrder(L, orbital.alpha.slice(aO, aO + 2 * L + 1), sphericalOrder);
-
-                const cutoffRadius = cutoffThreshold > 0
-                    ? Math.sqrt(-Math.log(cutoffThreshold) / arrayMin(shell.exponents))
-                    : 10000;
-
-                centers[4 * cO + 0] = atom.center[0];
-                centers[4 * cO + 1] = atom.center[1];
-                centers[4 * cO + 2] = atom.center[2];
-                centers[4 * cO + 3] = cutoffRadius * cutoffRadius;
-
-                info[4 * cO + 0] = L;
-                info[4 * cO + 1] = aO;
-                info[4 * cO + 2] = coeffO;
-                info[4 * cO + 3] = coeffO + shell.exponents.length;
-
-                for (let i = 0; i < a0.length; i++) alpha[aO + i] = a0[i];
-
-                const c0 = shell.coefficients[amIndex++];
-                for (let i = 0; i < shell.exponents.length; i++) {
-                    coeff[3 * (coeffO + i) + 0] = c0[i];
-                    coeff[3 * (coeffO + i) + 1] = shell.exponents[i];
-                }
-
-                if (c0.length > maxCoeffs) {
-                    maxCoeffs = c0.length;
-                }
-
-                cO++;
-                aO += 2 * L + 1;
-                coeffO += shell.exponents.length;
-            }
-        }
-    }
-
-    return {
-        uNCenters: centerCount,
-        uNAlpha: baseCount,
-        uNCoeff: coeffCount,
-        uMaxCoeffs: maxCoeffs,
-        tCenters: { width: centerCount, height: 1, array: centers },
-        tInfo: { width: centerCount, height: 1, array: info },
-        tCoeff: { width: coeffCount, height: 1, array: coeff },
-        tAlpha: { width: baseCount, height: 1, array: alpha },
-    };
-}

src/extensions/alpha-orbitals/gpu/shader.frag.ts

@@ -1,145 +0,0 @@
-/**
- * Copyright (c) 2020 mol* contributors, licensed under MIT, See LICENSE file for more info.
- *
- * @author David Sehnal <david.sehnal@gmail.com>
- */
-
-export const UTILS = `
-float L1(vec3 p, float a0, float a1, float a2) {
-    return a0 * p.z + a1 * p.x + a2 * p.y;
-}
-
-float L2(vec3 p, float a0, float a1, float a2, float a3, float a4) {
-    float x = p.x, y = p.y, z = p.z;
-    float xx = x * x, yy = y * y, zz = z * z;
-    return (
-        a0 * (-0.5 * xx - 0.5 * yy + zz) +
-        a1 * (1.7320508075688772 * x * z) +
-        a2 * (1.7320508075688772 * y * z) +
-        a3 * (0.8660254037844386 * xx - 0.8660254037844386 * yy) +
-        a4 * (1.7320508075688772 * x * y)
-    );
-}
-
-float L3(vec3 p, float a0, float a1, float a2, float a3, float a4, float a5, float a6) {
-    float x = p.x, y = p.y, z = p.z;
-    float xx = x * x, yy = y * y, zz = z * z;
-    float xxx = xx * x, yyy = yy * y, zzz = zz * z;
-    return (
-        a0 * (-1.5 * xx * z - 1.5 * yy * z + zzz) +
-        a1 * (-0.6123724356957945 * xxx - 0.6123724356957945 * x * yy + 2.449489742783178 * x * zz) +
-        a2 * (-0.6123724356957945 * xx * y - 0.6123724356957945 * yyy + 2.449489742783178 * y * zz) +
-        a3 * (1.9364916731037085 * xx * z - 1.9364916731037085 * yy * z) +
-        a4 * (3.872983346207417 * x * y * z) +
-        a5 * (0.7905694150420949 * xxx - 2.3717082451262845 * x * yy) +
-        a6 * (2.3717082451262845 * xx * y - 0.7905694150420949 * yyy)
-    );
-}
-
-float L4(vec3 p, float a0, float a1, float a2, float a3, float a4, float a5, float a6, float a7, float a8) {
-    float x = p.x, y = p.y, z = p.z;
-    float xx = x * x, yy = y * y, zz = z * z;
-    float xxx = xx * x, yyy = yy * y, zzz = zz * z;
-    float xxxx = xxx * x, yyyy = yyy * y, zzzz = zzz * z;
-    return (
-        a0 * (0.375 * xxxx + 0.75 * xx * yy + 0.375 * yyyy - 3.0 * xx * zz - 3.0 * yy * zz + zzzz) +
-        a1 * (-2.3717082451262845 * xxx * z - 2.3717082451262845 * x * yy * z + 3.1622776601683795 * x * zzz) +
-        a2 * (-2.3717082451262845 * xx * y * z - 2.3717082451262845 * yyy * z + 3.1622776601683795 * y * zzz) +
-        a3 * (-0.5590169943749475 * xxxx + 0.5590169943749475 * yyyy + 3.3541019662496847 * xx * zz - 3.3541019662496847 * yy * zz) +
-        a4 * (-1.118033988749895 * xxx * y - 1.118033988749895 * x * yyy + 6.708203932499369 * x * y * zz) +
-        a5 * (2.091650066335189 * xxx * z + -6.274950199005566 * x * yy * z) +
-        a6 * (6.274950199005566 * xx * y * z + -2.091650066335189 * yyy * z) +
-        a7 * (0.739509972887452 * xxxx - 4.437059837324712 * xx * yy + 0.739509972887452 * yyyy) +
-        a8 * (2.958039891549808 * xxx * y + -2.958039891549808 * x * yyy)
-    );
-}
-
-float alpha(float offset, float f) {
-    #ifdef WEBGL1
-        // in webgl1, the value is in the alpha channel!
-        return texture2D(tAlpha, vec2(offset * f, 0.5)).a;
-    #else
-        return texture2D(tAlpha, vec2(offset * f, 0.5)).x;
-    #endif
-}
-
-float Y(int L, vec3 X, float aO, float fA) {
-    if (L == 0) {
-        return alpha(aO, fA);
-    } else if (L == 1) {
-        return L1(X,
-            alpha(aO, fA), alpha(aO + 1.0, fA), alpha(aO + 2.0, fA)
-        );
-    } else if (L == 2) {
-        return L2(X,
-            alpha(aO, fA), alpha(aO + 1.0, fA), alpha(aO + 2.0, fA), alpha(aO + 3.0, fA), alpha(aO + 4.0, fA)
-        );
-    } else if (L == 3) {
-        return L3(X,
-            alpha(aO, fA), alpha(aO + 1.0, fA), alpha(aO + 2.0, fA), alpha(aO + 3.0, fA), alpha(aO + 4.0, fA),
-            alpha(aO + 5.0, fA), alpha(aO + 6.0, fA)
-        );
-    } else if (L == 4) {
-        return L4(X,
-            alpha(aO, fA), alpha(aO + 1.0, fA), alpha(aO + 2.0, fA), alpha(aO + 3.0, fA), alpha(aO + 4.0, fA),
-            alpha(aO + 5.0, fA), alpha(aO + 6.0, fA), alpha(aO + 7.0, fA), alpha(aO + 8.0, fA)
-        );
-    }
-    // TODO: do we need L > 4?
-    return 0.0;
-}
-
-#ifndef WEBGL1
-    float R(float R2, int start, int end, float fCoeff) {
-        float gauss = 0.0;
-        for (int i = start; i < end; i++) {
-            vec2 c = texture2D(tCoeff, vec2(float(i) * fCoeff, 0.5)).xy;
-            gauss += c.x * exp(-c.y * R2);
-        }
-        return gauss;
-    }
-#else
-    float R(float R2, int start, int end, float fCoeff) {
-        float gauss = 0.0;
-        int o = start;
-        for (int i = 0; i < uMaxCoeffs; i++) {
-            if (o >= end) break;
-
-            vec2 c = texture2D(tCoeff, vec2(float(o) * fCoeff, 0.5)).xy;
-            gauss += c.x * exp(-c.y * R2);
-            o++;
-        }
-        return gauss;
-    }
-#endif
-`;
-
-export const MAIN = `
-    float fCenter = 1.0 / float(uNCenters - 1);
-    float fCoeff = 1.0 / float(uNCoeff - 1);
-    float fA = 1.0 / float(uNAlpha - 1);
-
-    float v = 0.0;
-
-    for (int i = 0; i < uNCenters; i++) {
-        vec2 cCoord = vec2(float(i) * fCenter, 0.5);
-
-        vec4 center = texture2D(tCenters, cCoord);
-        vec3 X = xyz - center.xyz;
-        float R2 = dot(X, X);
-
-        // center.w is squared cutoff radius
-        if (R2 > center.w) {
-            continue;
-        }
-
-        vec4 info = texture2D(tInfo, cCoord);
-
-        int L = int(info.x);
-        float aO = info.y;
-        int coeffStart = int(info.z);
-        int coeffEnd = int(info.w);
-
-        v += R(R2, coeffStart, coeffEnd, fCoeff) * Y(L, X, aO, fA);
-    }
-`;

src/extensions/alpha-orbitals/orbitals.ts

@@ -1,130 +0,0 @@
-/**
- * Copyright (c) 2020-2022 mol* contributors, licensed under MIT, See LICENSE file for more info.
- *
- * Inspired by https://github.com/dgasmith/gau2grid.
- *
- * @author David Sehnal <david.sehnal@gmail.com>
- */
-
-import { sortArray } from '../../mol-data/util';
-import { canComputeGrid3dOnGPU } from '../../mol-gl/compute/grid3d';
-import { WebGLContext } from '../../mol-gl/webgl/context';
-import { Task } from '../../mol-task';
-import { isTimingMode } from '../../mol-util/debug';
-import { sphericalCollocation } from './collocation';
-import { AlphaOrbital, createGrid, CubeGrid, CubeGridComputationParams, initCubeGrid } from './data-model';
-import { gpuComputeAlphaOrbitalsGridValues } from './gpu/compute';
-
-export function createSphericalCollocationGrid(
-    params: CubeGridComputationParams, orbital: AlphaOrbital, webgl?: WebGLContext
-): Task<CubeGrid> {
-    return Task.create('Spherical Collocation Grid', async (ctx) => {
-        const cubeGrid = initCubeGrid(params);
-
-        let matrix: Float32Array;
-        if (canComputeGrid3dOnGPU(webgl)) {
-            if (isTimingMode) webgl.timer.mark('createSphericalCollocationGrid');
-            matrix = await gpuComputeAlphaOrbitalsGridValues(ctx, webgl, cubeGrid, orbital);
-            if (isTimingMode) webgl.timer.markEnd('createSphericalCollocationGrid');
-        } else {
-            // console.time('cpu');
-            matrix = await sphericalCollocation(cubeGrid, orbital, ctx);
-            // console.timeEnd('cpu');
-        }
-
-        const grid = createGrid(cubeGrid, matrix, [0, 1, 2]);
-        let isovalues: { negative?: number, positive?: number } | undefined;
-
-        if (!params.doNotComputeIsovalues) {
-            isovalues = computeOrbitalIsocontourValues(matrix, 0.85);
-        }
-
-        return { grid, isovalues };
-    });
-}
-
-export function computeOrbitalIsocontourValues(input: Float32Array, cumulativeThreshold: number) {
-    let weightSum = 0;
-    for (let i = 0, _i = input.length; i < _i; i++) {
-        const v = input[i];
-        const w = v * v;
-        weightSum += w;
-    }
-    const avgWeight = weightSum / input.length;
-    let minWeight = 3 * avgWeight;
-
-    // do not try to identify isovalues for degenerate data
-    // e.g. all values are almost same
-    if (Math.abs(avgWeight - input[0] * input[0]) < 1e-5) {
-        return { negative: void 0, positive: void 0 };
-    }
-
-    let size = 0;
-    while (true) {
-        let csum = 0;
-        size = 0;
-        for (let i = 0, _i = input.length; i < _i; i++) {
-            const v = input[i];
-            const w = v * v;
-            if (w >= minWeight) {
-                csum += w;
-                size++;
-            }
-        }
-
-        if (csum / weightSum > cumulativeThreshold) {
-            break;
-        }
-
-        minWeight -= avgWeight;
-    }
-
-    const values = new Float32Array(size);
-    const weights = new Float32Array(size);
-    const indices = new Int32Array(size);
-
-    let o = 0;
-    for (let i = 0, _i = input.length; i < _i; i++) {
-        const v = input[i];
-        const w = v * v;
-        if (w >= minWeight) {
-            values[o] = v;
-            weights[o] = w;
-            indices[o] = o;
-            o++;
-        }
-    }
-
-    sortArray(
-        indices,
-        (indices, i, j) => weights[indices[j]] - weights[indices[i]]
-    );
-
-    let cweight = 0,
-        cutoffIndex = 0;
-    for (let i = 0; i < size; i++) {
-        cweight += weights[indices[i]];
-
-        if (cweight / weightSum >= cumulativeThreshold) {
-            cutoffIndex = i;
-            break;
-        }
-    }
-
-    let positive = Number.POSITIVE_INFINITY,
-        negative = Number.NEGATIVE_INFINITY;
-
-    for (let i = 0; i < cutoffIndex; i++) {
-        const v = values[indices[i]];
-        if (v > 0) {
-            if (v < positive) positive = v;
-        } else if (v < 0) {
-            if (v > negative) negative = v;
-        }
-    }
-
-    return {
-        negative: negative !== Number.NEGATIVE_INFINITY ? negative : void 0,
-        positive: positive !== Number.POSITIVE_INFINITY ? positive : void 0,
-    };
-}