molstar 4.0.1 → 4.2.0

package/lib/commonjs/mol-theme/emissive.js

@@ -0,0 +1,137 @@
+"use strict";
+/**
+ * Copyright (c) 2024 mol* contributors, licensed under MIT, See LICENSE file for more info.
+ *
+ * @author Alexander Rose <alexander.rose@weirdbyte.de>
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Emissive = void 0;
+const loci_1 = require("../mol-model/loci");
+const structure_1 = require("../mol-model/structure");
+const script_1 = require("../mol-script/script");
+function Emissive(kind, layers) {
+    return { kind, layers };
+}
+exports.Emissive = Emissive;
+(function (Emissive) {
+    Emissive.Empty = { kind: 'empty-loci', layers: [] };
+    function areEqual(eA, eB) {
+        if (eA.layers.length === 0 && eB.layers.length === 0)
+            return true;
+        if (eA.layers.length !== eB.layers.length)
+            return false;
+        for (let i = 0, il = eA.layers.length; i < il; ++i) {
+            if (eA.layers[i].value !== eB.layers[i].value)
+                return false;
+            if (!loci_1.Loci.areEqual(eA.layers[i].loci, eB.layers[i].loci))
+                return false;
+        }
+        return true;
+    }
+    Emissive.areEqual = areEqual;
+    function isEmpty(emissive) {
+        return emissive.layers.length === 0;
+    }
+    Emissive.isEmpty = isEmpty;
+    function remap(emissive, structure) {
+        if (emissive.kind === 'element-loci') {
+            const layers = [];
+            for (const layer of emissive.layers) {
+                let { loci, value } = layer;
+                loci = structure_1.StructureElement.Loci.remap(loci, structure);
+                if (!structure_1.StructureElement.Loci.isEmpty(loci)) {
+                    layers.push({ loci, value });
+                }
+            }
+            return { kind: 'element-loci', layers };
+        }
+        else {
+            return emissive;
+        }
+    }
+    Emissive.remap = remap;
+    function merge(emissive) {
+        if (isEmpty(emissive))
+            return emissive;
+        if (emissive.kind === 'element-loci') {
+            const { structure } = emissive.layers[0].loci;
+            const map = new Map();
+            let shadowed = structure_1.StructureElement.Loci.none(structure);
+            for (let i = 0, il = emissive.layers.length; i < il; ++i) {
+                let { loci, value } = emissive.layers[il - i - 1]; // process from end
+                loci = structure_1.StructureElement.Loci.subtract(loci, shadowed);
+                shadowed = structure_1.StructureElement.Loci.union(loci, shadowed);
+                if (!structure_1.StructureElement.Loci.isEmpty(loci)) {
+                    if (map.has(value)) {
+                        loci = structure_1.StructureElement.Loci.union(loci, map.get(value));
+                    }
+                    map.set(value, loci);
+                }
+            }
+            const layers = [];
+            map.forEach((loci, value) => {
+                layers.push({ loci, value });
+            });
+            return { kind: 'element-loci', layers };
+        }
+        else {
+            return emissive;
+        }
+    }
+    Emissive.merge = merge;
+    function filter(emissive, filter) {
+        if (isEmpty(emissive))
+            return emissive;
+        if (emissive.kind === 'element-loci') {
+            const { structure } = emissive.layers[0].loci;
+            const layers = [];
+            for (const layer of emissive.layers) {
+                let { loci, value } = layer;
+                // filter by first map to the `filter` structure and
+                // then map back to the original structure of the emissive loci
+                const filtered = structure_1.StructureElement.Loci.remap(loci, filter);
+                loci = structure_1.StructureElement.Loci.remap(filtered, structure);
+                if (!structure_1.StructureElement.Loci.isEmpty(loci)) {
+                    layers.push({ loci, value });
+                }
+            }
+            return { kind: 'element-loci', layers };
+        }
+        else {
+            return emissive;
+        }
+    }
+    Emissive.filter = filter;
+    function ofScript(scriptLayers, structure) {
+        const layers = [];
+        for (let i = 0, il = scriptLayers.length; i < il; ++i) {
+            const { script, value } = scriptLayers[i];
+            const loci = script_1.Script.toLoci(script, structure);
+            if (!structure_1.StructureElement.Loci.isEmpty(loci)) {
+                layers.push({ loci, value });
+            }
+        }
+        return { kind: 'element-loci', layers };
+    }
+    Emissive.ofScript = ofScript;
+    function ofBundle(bundleLayers, structure) {
+        const layers = [];
+        for (let i = 0, il = bundleLayers.length; i < il; ++i) {
+            const { bundle, value } = bundleLayers[i];
+            const loci = structure_1.StructureElement.Bundle.toLoci(bundle, structure.root);
+            layers.push({ loci, value });
+        }
+        return { kind: 'element-loci', layers };
+    }
+    Emissive.ofBundle = ofBundle;
+    function toBundle(emissive) {
+        const layers = [];
+        for (let i = 0, il = emissive.layers.length; i < il; ++i) {
+            const { loci, value } = emissive.layers[i];
+            const bundle = structure_1.StructureElement.Bundle.fromLoci(loci);
+            layers.push({ bundle, value });
+        }
+        return { kind: 'element-loci', layers };
+    }
+    Emissive.toBundle = toBundle;
+})(Emissive || (exports.Emissive = Emissive = {}));

package/lib/commonjs/mol-theme/substance.d.ts

@@ -21,7 +21,7 @@ declare namespace Substance {
     };
     const Empty: Substance;
     function areEqual(sA: Substance, sB: Substance): boolean;
-    function isEmpty(overpaint: Substance): boolean;
+    function isEmpty(substance: Substance): boolean;
     function remap(substance: Substance, structure: Structure): Substance;
     function merge(substance: Substance): Substance;
     function filter(substance: Substance, filter: Structure): Substance;

package/lib/commonjs/mol-theme/substance.js

@@ -33,8 +33,8 @@ exports.Substance = Substance;
         return true;
     }
     Substance.areEqual = areEqual;
-    function isEmpty(overpaint) {
-        return overpaint.layers.length === 0;
+    function isEmpty(substance) {
+        return substance.layers.length === 0;
     }
     Substance.isEmpty = isEmpty;
     function remap(substance, structure) {

package/lib/commonjs/mol-theme/transparency.d.ts

@@ -18,7 +18,6 @@ declare namespace Transparency {
         readonly value: number;
     };
     const Empty: Transparency;
-    type Variant = 'single' | 'multi';
     function areEqual(tA: Transparency, tB: Transparency): boolean;
     function isEmpty(transparency: Transparency): boolean;
     function remap(transparency: Transparency, structure: Structure): Transparency;

package/lib/commonjs/mol-util/input/input-observer.js

@@ -647,6 +647,8 @@ var InputObserver;
             gestureDelta(ev, true);
         }
         function onResize() {
+            width = element.clientWidth * pixelRatio();
+            height = element.clientHeight * pixelRatio();
             resize.next({});
         }
         function insideBounds(pos) {

package/lib/commonjs/mol-util/set.d.ts

@@ -1,5 +1,5 @@
 /**
- * Copyright (c) 2018-2023 mol* contributors, licensed under MIT, See LICENSE file for more info.
+ * Copyright (c) 2018-2024 mol* contributors, licensed under MIT, See LICENSE file for more info.
  *
  * @author Alexander Rose <alexander.rose@weirdbyte.de>
  */

package/lib/commonjs/mol-util/set.js

@@ -1,6 +1,6 @@
 "use strict";
 /**
- * Copyright (c) 2018-2023 mol* contributors, licensed under MIT, See LICENSE file for more info.
+ * Copyright (c) 2018-2024 mol* contributors, licensed under MIT, See LICENSE file for more info.
  *
  * @author Alexander Rose <alexander.rose@weirdbyte.de>
  */
@@ -15,6 +15,8 @@ var SetUtils;
     SetUtils.toArray = toArray;
     /** Test if set a contains all elements of set b. */
     function isSuperset(setA, setB) {
+        if (setA === setB)
+            return true;
         if (setA.size < setB.size)
             return false;
         for (const elem of setB) {
@@ -36,6 +38,8 @@ var SetUtils;
     /** Create set containing elements of both set a and set b. */
     function union(setA, setB) {
         const union = new Set(setA);
+        if (setA === setB)
+            return union;
         for (const elem of setB)
             union.add(elem);
         return union;
@@ -65,6 +69,8 @@ var SetUtils;
     SetUtils.unionManyArrays = unionManyArrays;
     /** Create set containing elements of set a that are also in set b. */
     function intersection(setA, setB) {
+        if (setA === setB)
+            return new Set(setA);
         const intersection = new Set();
         for (const elem of setB) {
             if (setA.has(elem))
@@ -74,6 +80,8 @@ var SetUtils;
     }
     SetUtils.intersection = intersection;
     function areIntersecting(setA, setB) {
+        if (setA === setB)
+            return setA.size > 0;
         if (setA.size < setB.size)
             [setA, setB] = [setB, setA];
         for (const elem of setB) {
@@ -84,6 +92,8 @@ var SetUtils;
     }
     SetUtils.areIntersecting = areIntersecting;
     function intersectionSize(setA, setB) {
+        if (setA === setB)
+            return setA.size;
         if (setA.size < setB.size)
             [setA, setB] = [setB, setA];
         let count = 0;
@@ -96,6 +106,8 @@ var SetUtils;
     SetUtils.intersectionSize = intersectionSize;
     /** Create set containing elements of set a that are not in set b. */
     function difference(setA, setB) {
+        if (setA === setB)
+            return new Set();
         const difference = new Set(setA);
         for (const elem of setB)
             difference.delete(elem);
@@ -104,6 +116,8 @@ var SetUtils;
     SetUtils.difference = difference;
     /** Number of elements that are in set a but not in set b. */
     function differenceSize(setA, setB) {
+        if (setA === setB)
+            return 0;
         let count = setA.size;
         for (const elem of setA) {
             if (setB.has(elem))
@@ -114,6 +128,8 @@ var SetUtils;
     SetUtils.differenceSize = differenceSize;
     /** Test if set a and b contain the same elements. */
     function areEqual(setA, setB) {
+        if (setA === setB)
+            return true;
         if (setA.size !== setB.size)
             return false;
         for (const elem of setB) {

package/lib/commonjs/servers/common/swagger-ui/indexTemplate.js

@@ -1,70 +1,70 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.indexTemplate = void 0;
-exports.indexTemplate = `<!DOCTYPE html>
-<html lang="en">
-    <head>
-        <meta charset="UTF-8">
-        <title>\${title}</title>
-        <link rel="stylesheet" type="text/css" href="\${apiPrefix}/swagger-ui.css" >
-        \${shortcutIconLink}
-
-        <style>
-            html
-            {
-                box-sizing: border-box;
-                overflow: -moz-scrollbars-vertical;
-                overflow-y: scroll;
-            }
-            *,
-            *:before,
-            *:after
-            {
-                box-sizing: inherit;
-            }
-            body
-            {
-                margin:0;
-                background: #fafafa;
-            }
-        </style>
-    </head>
-
-    <body>
-        <div id="swagger-ui"></div>
-
-        <script src="\${apiPrefix}/swagger-ui-bundle.js"> </script>
-        <script src="\${apiPrefix}/swagger-ui-standalone-preset.js"> </script>
-        <script>
-            function HidePlugin() {
-                // this plugin overrides some components to return nothing
-                return {
-                    components: {
-                        Topbar: function () { return null },
-                        Models: function () { return null },
-                    }
-                }
-            }
-            window.onload = function () {
-                var ui = SwaggerUIBundle({
-                    url: '\${openapiJsonUrl}',
-                    validatorUrl: null,
-                    docExpansion: 'list',
-                    dom_id: '#swagger-ui',
-                    deepLinking: true,
-                    presets: [
-                        SwaggerUIBundle.presets.apis,
-                        SwaggerUIStandalonePreset
-                    ],
-                    syntaxHighlight: { activated: false, theme: 'agate' },
-                    plugins: [
-                        SwaggerUIBundle.plugins.DownloadUrl,
-                        HidePlugin
-                    ],
-                    layout: 'StandaloneLayout'
-                })
-                window.ui = ui
-            }
-        </script>
-    </body>
+exports.indexTemplate = `<!DOCTYPE html>
+<html lang="en">
+    <head>
+        <meta charset="UTF-8">
+        <title>\${title}</title>
+        <link rel="stylesheet" type="text/css" href="\${apiPrefix}/swagger-ui.css" >
+        \${shortcutIconLink}
+
+        <style>
+            html
+            {
+                box-sizing: border-box;
+                overflow: -moz-scrollbars-vertical;
+                overflow-y: scroll;
+            }
+            *,
+            *:before,
+            *:after
+            {
+                box-sizing: inherit;
+            }
+            body
+            {
+                margin:0;
+                background: #fafafa;
+            }
+        </style>
+    </head>
+
+    <body>
+        <div id="swagger-ui"></div>
+
+        <script src="\${apiPrefix}/swagger-ui-bundle.js"> </script>
+        <script src="\${apiPrefix}/swagger-ui-standalone-preset.js"> </script>
+        <script>
+            function HidePlugin() {
+                // this plugin overrides some components to return nothing
+                return {
+                    components: {
+                        Topbar: function () { return null },
+                        Models: function () { return null },
+                    }
+                }
+            }
+            window.onload = function () {
+                var ui = SwaggerUIBundle({
+                    url: '\${openapiJsonUrl}',
+                    validatorUrl: null,
+                    docExpansion: 'list',
+                    dom_id: '#swagger-ui',
+                    deepLinking: true,
+                    presets: [
+                        SwaggerUIBundle.presets.apis,
+                        SwaggerUIStandalonePreset
+                    ],
+                    syntaxHighlight: { activated: false, theme: 'agate' },
+                    plugins: [
+                        SwaggerUIBundle.plugins.DownloadUrl,
+                        HidePlugin
+                    ],
+                    layout: 'StandaloneLayout'
+                })
+                window.ui = ui
+            }
+        </script>
+    </body>
 </html>`;

package/lib/commonjs/servers/volume/config.js

@@ -23,9 +23,9 @@ function addLimitsArgs(parser) {
     parser.add_argument('--maxRequestBlockCount', {
         default: DefaultLimitsConfig.maxRequestBlockCount,
         metavar: 'COUNT',
-        help: `Maximum number of blocks that could be read in 1 query.
-This is somewhat tied to the maxOutputSizeInVoxelCountByPrecisionLevel
-in that the <maximum number of voxel> = maxRequestBlockCount * <block size>^3.
+        help: `Maximum number of blocks that could be read in 1 query.
+This is somewhat tied to the maxOutputSizeInVoxelCountByPrecisionLevel
+in that the <maximum number of voxel> = maxRequestBlockCount * <block size>^3.
 The default block size is 96 which corresponds to 28,311,552 voxels with 32 max blocks.`
     });
     parser.add_argument('--maxFractionalBoxVolume', {
@@ -37,8 +37,8 @@ The default block size is 96 which corresponds to 28,311,552 voxels with 32 max
         nargs: '+',
         default: DefaultLimitsConfig.maxOutputSizeInVoxelCountByPrecisionLevel,
         metavar: 'LEVEL',
-        help: `What is the (approximate) maximum desired size in voxel count by precision level
-Rule of thumb: <response gzipped size> in [<voxel count> / 8, <voxel count> / 4].
+        help: `What is the (approximate) maximum desired size in voxel count by precision level
+Rule of thumb: <response gzipped size> in [<voxel count> / 8, <voxel count> / 4].
 The maximum number of voxels is tied to maxRequestBlockCount.`
     });
 }