molstar 3.3.1 → 3.4.0

package/lib/commonjs/extensions/zenodo/ui.d.ts

@@ -0,0 +1,61 @@
+/**
+ * Copyright (c) 2022 mol* contributors, licensed under MIT, See LICENSE file for more info.
+ *
+ * @author Alexander Rose <alexander.rose@weirdbyte.de>
+ */
+/// <reference types="react" />
+import { CollapsableControls, CollapsableState } from '../../mol-plugin-ui/base';
+import { PluginContext } from '../../mol-plugin/context';
+import { ParamDefinition as PD } from '../../mol-util/param-definition';
+declare type ZenodoFile = {
+    bucket: string;
+    checksum: string;
+    key: string;
+    links: {
+        [key: string]: string;
+        self: string;
+    };
+    size: number;
+    type: string;
+};
+declare type ZenodoRecord = {
+    id: number;
+    conceptdoi: string;
+    conceptrecid: string;
+    created: string;
+    doi: string;
+    files: ZenodoFile[];
+    revision: number;
+    updated: string;
+    metadata: {
+        title: string;
+    };
+};
+interface State {
+    busy?: boolean;
+    recordValues: PD.Values<typeof ZenodoImportParams>;
+    importValues?: PD.Values<ImportParams>;
+    importParams?: ImportParams;
+    record?: ZenodoRecord;
+    files?: ZenodoFile[];
+}
+declare const ZenodoImportParams: {
+    record: PD.Text<string>;
+};
+declare function createImportParams(files: ZenodoFile[], plugin: PluginContext): {
+    type: PD.Mapped<PD.NamedParams<any, string> | PD.NamedParams<any, number>>;
+};
+declare type ImportParams = ReturnType<typeof createImportParams>;
+export declare class ZenodoImportUI extends CollapsableControls<{}, State> {
+    protected defaultState(): State & CollapsableState;
+    private recordParamsOnChange;
+    private importParamsOnChange;
+    private loadRecord;
+    private loadFile;
+    private clearRecord;
+    private renderLoadRecord;
+    private renderRecordInfo;
+    private renderImportFile;
+    protected renderControls(): JSX.Element | null;
+}
+export {};

package/lib/commonjs/extensions/zenodo/ui.js

@@ -0,0 +1,306 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ZenodoImportUI = void 0;
+var tslib_1 = require("tslib");
+var jsx_runtime_1 = require("react/jsx-runtime");
+/**
+ * Copyright (c) 2022 mol* contributors, licensed under MIT, See LICENSE file for more info.
+ *
+ * @author Alexander Rose <alexander.rose@weirdbyte.de>
+ */
+var file_1 = require("../../mol-plugin-state/actions/file");
+var structure_1 = require("../../mol-plugin-state/actions/structure");
+var volume_1 = require("../../mol-plugin-state/actions/volume");
+var coordinates_1 = require("../../mol-plugin-state/formats/coordinates");
+var topology_1 = require("../../mol-plugin-state/formats/topology");
+var trajectory_1 = require("../../mol-plugin-state/formats/trajectory");
+var volume_2 = require("../../mol-plugin-state/formats/volume");
+var base_1 = require("../../mol-plugin-ui/base");
+var common_1 = require("../../mol-plugin-ui/controls/common");
+var icons_1 = require("../../mol-plugin-ui/controls/icons");
+var parameters_1 = require("../../mol-plugin-ui/controls/parameters");
+var mol_util_1 = require("../../mol-util");
+var param_definition_1 = require("../../mol-util/param-definition");
+var ZenodoImportParams = {
+    record: param_definition_1.ParamDefinition.Text('', { description: 'Zenodo ID.' })
+};
+function createImportParams(files, plugin) {
+    var modelOpts = [];
+    var topologyOpts = [];
+    var coordinatesOpts = [];
+    var volumeOpts = [];
+    var compressedOpts = [];
+    var structureExts = new Map();
+    var coordinatesExts = new Map();
+    var topologyExts = new Map();
+    var volumeExts = new Map();
+    for (var _i = 0, _a = plugin.dataFormats.list; _i < _a.length; _i++) {
+        var _b = _a[_i], _c = _b.provider, category = _c.category, binaryExtensions = _c.binaryExtensions, stringExtensions = _c.stringExtensions, name_1 = _b.name;
+        if (category === trajectory_1.TrajectoryFormatCategory) {
+            if (binaryExtensions)
+                for (var _d = 0, binaryExtensions_1 = binaryExtensions; _d < binaryExtensions_1.length; _d++) {
+                    var e = binaryExtensions_1[_d];
+                    structureExts.set(e, { format: name_1, isBinary: true });
+                }
+            if (stringExtensions)
+                for (var _e = 0, stringExtensions_1 = stringExtensions; _e < stringExtensions_1.length; _e++) {
+                    var e = stringExtensions_1[_e];
+                    structureExts.set(e, { format: name_1, isBinary: false });
+                }
+        }
+        else if (category === volume_2.VolumeFormatCategory) {
+            if (binaryExtensions)
+                for (var _f = 0, binaryExtensions_2 = binaryExtensions; _f < binaryExtensions_2.length; _f++) {
+                    var e = binaryExtensions_2[_f];
+                    volumeExts.set(e, { format: name_1, isBinary: true });
+                }
+            if (stringExtensions)
+                for (var _g = 0, stringExtensions_2 = stringExtensions; _g < stringExtensions_2.length; _g++) {
+                    var e = stringExtensions_2[_g];
+                    volumeExts.set(e, { format: name_1, isBinary: false });
+                }
+        }
+        else if (category === coordinates_1.CoordinatesFormatCategory) {
+            if (binaryExtensions)
+                for (var _h = 0, binaryExtensions_3 = binaryExtensions; _h < binaryExtensions_3.length; _h++) {
+                    var e = binaryExtensions_3[_h];
+                    coordinatesExts.set(e, { format: name_1, isBinary: true });
+                }
+            if (stringExtensions)
+                for (var _j = 0, stringExtensions_3 = stringExtensions; _j < stringExtensions_3.length; _j++) {
+                    var e = stringExtensions_3[_j];
+                    coordinatesExts.set(e, { format: name_1, isBinary: false });
+                }
+        }
+        else if (category === topology_1.TopologyFormatCategory) {
+            if (binaryExtensions)
+                for (var _k = 0, binaryExtensions_4 = binaryExtensions; _k < binaryExtensions_4.length; _k++) {
+                    var e = binaryExtensions_4[_k];
+                    topologyExts.set(e, { format: name_1, isBinary: true });
+                }
+            if (stringExtensions)
+                for (var _l = 0, stringExtensions_4 = stringExtensions; _l < stringExtensions_4.length; _l++) {
+                    var e = stringExtensions_4[_l];
+                    topologyExts.set(e, { format: name_1, isBinary: false });
+                }
+        }
+    }
+    for (var _m = 0, files_1 = files; _m < files_1.length; _m++) {
+        var file = files_1[_m];
+        var label = "".concat(file.key, " (").concat((0, mol_util_1.formatBytes)(file.size), ")");
+        if (structureExts.has(file.type)) {
+            var _o = structureExts.get(file.type), format = _o.format, isBinary = _o.isBinary;
+            modelOpts.push(["".concat(file.links.self, "|").concat(format, "|").concat(isBinary), label]);
+            topologyOpts.push(["".concat(file.links.self, "|").concat(format, "|").concat(isBinary), label]);
+        }
+        else if (volumeExts.has(file.type)) {
+            var _p = volumeExts.get(file.type), format = _p.format, isBinary = _p.isBinary;
+            volumeOpts.push(["".concat(file.links.self, "|").concat(format, "|").concat(isBinary), label]);
+        }
+        else if (topologyExts.has(file.type)) {
+            var _q = topologyExts.get(file.type), format = _q.format, isBinary = _q.isBinary;
+            topologyOpts.push(["".concat(file.links.self, "|").concat(format, "|").concat(isBinary), label]);
+        }
+        else if (coordinatesExts.has(file.type)) {
+            var _r = coordinatesExts.get(file.type), format = _r.format, isBinary = _r.isBinary;
+            coordinatesOpts.push(["".concat(file.links.self, "|").concat(format, "|").concat(isBinary), label]);
+        }
+        else if (file.type === 'zip') {
+            compressedOpts.push(["".concat(file.links.self, "|").concat(file.type, "|true"), label]);
+        }
+    }
+    var params = {};
+    var defaultType = '';
+    if (modelOpts.length) {
+        defaultType = 'structure';
+        params.structure = param_definition_1.ParamDefinition.Select(modelOpts[0][0], modelOpts);
+    }
+    if (topologyOpts.length && coordinatesOpts.length) {
+        if (!defaultType)
+            defaultType = 'trajectory';
+        params.trajectory = param_definition_1.ParamDefinition.Group({
+            topology: param_definition_1.ParamDefinition.Select(topologyOpts[0][0], topologyOpts),
+            coordinates: param_definition_1.ParamDefinition.Select(coordinatesOpts[0][0], coordinatesOpts),
+        }, { isFlat: true });
+    }
+    if (volumeOpts.length) {
+        if (!defaultType)
+            defaultType = 'volume';
+        params.volume = param_definition_1.ParamDefinition.Select(volumeOpts[0][0], volumeOpts);
+    }
+    if (compressedOpts.length) {
+        if (!defaultType)
+            defaultType = 'compressed';
+        params.compressed = param_definition_1.ParamDefinition.Select(compressedOpts[0][0], compressedOpts);
+    }
+    return {
+        type: param_definition_1.ParamDefinition.MappedStatic(defaultType, Object.keys(params).length ? params : { '': param_definition_1.ParamDefinition.EmptyGroup() })
+    };
+}
+var ZenodoImportUI = /** @class */ (function (_super) {
+    tslib_1.__extends(ZenodoImportUI, _super);
+    function ZenodoImportUI() {
+        var _this = _super !== null && _super.apply(this, arguments) || this;
+        _this.recordParamsOnChange = function (values) {
+            _this.setState({ recordValues: values });
+        };
+        _this.importParamsOnChange = function (values) {
+            _this.setState({ importValues: values });
+        };
+        _this.loadRecord = function () { return tslib_1.__awaiter(_this, void 0, void 0, function () {
+            var record, importParams, e_1;
+            return tslib_1.__generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        _a.trys.push([0, 2, , 3]);
+                        this.setState({ busy: true });
+                        return [4 /*yield*/, this.plugin.runTask(this.plugin.fetch({ url: "https://zenodo.org/api/records/".concat(this.state.recordValues.record), type: 'json' }))];
+                    case 1:
+                        record = _a.sent();
+                        importParams = createImportParams(record.files, this.plugin);
+                        this.setState({
+                            record: record,
+                            files: record.files,
+                            busy: false,
+                            importValues: param_definition_1.ParamDefinition.getDefaultValues(importParams),
+                            importParams: importParams
+                        });
+                        return [3 /*break*/, 3];
+                    case 2:
+                        e_1 = _a.sent();
+                        console.error(e_1);
+                        this.plugin.log.error("Failed to load Zenodo record '".concat(this.state.recordValues.record, "'"));
+                        this.setState({ busy: false });
+                        return [3 /*break*/, 3];
+                    case 3: return [2 /*return*/];
+                }
+            });
+        }); };
+        _this.loadFile = function (values) { return tslib_1.__awaiter(_this, void 0, void 0, function () {
+            var t, defaultParams, _a, url, format, isBinary, _b, topologyUrl, topologyFormat, topologyIsBinary, _c, coordinatesUrl, coordinatesFormat, coordinatesIsBinary, _d, url, format, isBinary, _e, url, format, isBinary, e_2;
+            return tslib_1.__generator(this, function (_f) {
+                switch (_f.label) {
+                    case 0:
+                        _f.trys.push([0, 9, 10, 11]);
+                        this.setState({ busy: true });
+                        t = values.type;
+                        if (!(t.name === 'structure')) return [3 /*break*/, 2];
+                        defaultParams = structure_1.DownloadStructure.createDefaultParams(this.plugin.state.data.root.obj, this.plugin);
+                        _a = t.params.split('|'), url = _a[0], format = _a[1], isBinary = _a[2];
+                        return [4 /*yield*/, this.plugin.runTask(this.plugin.state.data.applyAction(structure_1.DownloadStructure, {
+                                source: {
+                                    name: 'url',
+                                    params: {
+                                        url: url,
+                                        format: format,
+                                        isBinary: isBinary === 'true',
+                                        options: defaultParams.source.params.options,
+                                    }
+                                }
+                            }))];
+                    case 1:
+                        _f.sent();
+                        return [3 /*break*/, 8];
+                    case 2:
+                        if (!(t.name === 'trajectory')) return [3 /*break*/, 4];
+                        _b = t.params.topology.split('|'), topologyUrl = _b[0], topologyFormat = _b[1], topologyIsBinary = _b[2];
+                        _c = t.params.coordinates.split('|'), coordinatesUrl = _c[0], coordinatesFormat = _c[1], coordinatesIsBinary = _c[2];
+                        return [4 /*yield*/, this.plugin.runTask(this.plugin.state.data.applyAction(structure_1.LoadTrajectory, {
+                                source: {
+                                    name: 'url',
+                                    params: {
+                                        model: {
+                                            url: topologyUrl,
+                                            format: topologyFormat,
+                                            isBinary: topologyIsBinary === 'true',
+                                        },
+                                        coordinates: {
+                                            url: coordinatesUrl,
+                                            format: coordinatesFormat,
+                                            isBinary: coordinatesIsBinary === 'true',
+                                        },
+                                    }
+                                }
+                            }))];
+                    case 3:
+                        _f.sent();
+                        return [3 /*break*/, 8];
+                    case 4:
+                        if (!(t.name === 'volume')) return [3 /*break*/, 6];
+                        _d = t.params.split('|'), url = _d[0], format = _d[1], isBinary = _d[2];
+                        return [4 /*yield*/, this.plugin.runTask(this.plugin.state.data.applyAction(volume_1.DownloadDensity, {
+                                source: {
+                                    name: 'url',
+                                    params: {
+                                        url: url,
+                                        format: format,
+                                        isBinary: isBinary === 'true',
+                                    }
+                                }
+                            }))];
+                    case 5:
+                        _f.sent();
+                        return [3 /*break*/, 8];
+                    case 6:
+                        if (!(t.name === 'compressed')) return [3 /*break*/, 8];
+                        _e = t.params.split('|'), url = _e[0], format = _e[1], isBinary = _e[2];
+                        return [4 /*yield*/, this.plugin.runTask(this.plugin.state.data.applyAction(file_1.DownloadFile, {
+                                url: url,
+                                format: format,
+                                isBinary: isBinary === 'true',
+                                visuals: true
+                            }))];
+                    case 7:
+                        _f.sent();
+                        _f.label = 8;
+                    case 8: return [3 /*break*/, 11];
+                    case 9:
+                        e_2 = _f.sent();
+                        console.error(e_2);
+                        this.plugin.log.error("Failed to load Zenodo file");
+                        return [3 /*break*/, 11];
+                    case 10:
+                        this.setState({ busy: false });
+                        return [7 /*endfinally*/];
+                    case 11: return [2 /*return*/];
+                }
+            });
+        }); };
+        _this.clearRecord = function () {
+            _this.setState({
+                importValues: undefined,
+                importParams: undefined,
+                record: undefined,
+                files: undefined
+            });
+        };
+        return _this;
+    }
+    ZenodoImportUI.prototype.defaultState = function () {
+        return {
+            header: 'Zenodo Import',
+            isCollapsed: true,
+            brand: { accent: 'cyan', svg: icons_1.OpenInBrowserSvg },
+            recordValues: param_definition_1.ParamDefinition.getDefaultValues(ZenodoImportParams),
+            importValues: undefined,
+            importParams: undefined,
+            record: undefined,
+            files: undefined,
+        };
+    };
+    ZenodoImportUI.prototype.renderLoadRecord = function () {
+        return (0, jsx_runtime_1.jsxs)("div", tslib_1.__assign({ style: { marginBottom: 10 } }, { children: [(0, jsx_runtime_1.jsx)(parameters_1.ParameterControls, { params: ZenodoImportParams, values: this.state.recordValues, onChangeValues: this.recordParamsOnChange, isDisabled: this.state.busy }), (0, jsx_runtime_1.jsx)(common_1.Button, tslib_1.__assign({ onClick: this.loadRecord, style: { marginTop: 1 }, disabled: this.state.busy || !this.state.recordValues.record }, { children: "Load Record" }))] }));
+    };
+    ZenodoImportUI.prototype.renderRecordInfo = function (record) {
+        return (0, jsx_runtime_1.jsxs)("div", tslib_1.__assign({ style: { marginBottom: 10 } }, { children: [(0, jsx_runtime_1.jsx)("div", tslib_1.__assign({ className: 'msp-help-text' }, { children: (0, jsx_runtime_1.jsxs)("div", { children: ["Record ", "".concat(record.id), ": ", (0, jsx_runtime_1.jsx)("i", { children: "".concat(record.metadata.title) })] }) })), (0, jsx_runtime_1.jsx)(common_1.Button, tslib_1.__assign({ onClick: this.clearRecord, style: { marginTop: 1 }, disabled: this.state.busy }, { children: "Clear" }))] }));
+    };
+    ZenodoImportUI.prototype.renderImportFile = function (params, values) {
+        var _this = this;
+        return values.type.name ? (0, jsx_runtime_1.jsxs)("div", tslib_1.__assign({ style: { marginBottom: 10 } }, { children: [(0, jsx_runtime_1.jsx)(parameters_1.ParameterControls, { params: params, values: this.state.importValues, onChangeValues: this.importParamsOnChange, isDisabled: this.state.busy }), (0, jsx_runtime_1.jsx)(common_1.Button, tslib_1.__assign({ onClick: function () { return _this.loadFile(values); }, style: { marginTop: 1 }, disabled: this.state.busy }, { children: "Import File" }))] })) : (0, jsx_runtime_1.jsx)("div", tslib_1.__assign({ className: 'msp-help-text', style: { marginBottom: 10 } }, { children: (0, jsx_runtime_1.jsx)("div", { children: "No supported files" }) }));
+    };
+    ZenodoImportUI.prototype.renderControls = function () {
+        return (0, jsx_runtime_1.jsxs)(jsx_runtime_1.Fragment, { children: [!this.state.record ? this.renderLoadRecord() : null, this.state.record ? this.renderRecordInfo(this.state.record) : null, this.state.importParams && this.state.importValues ? this.renderImportFile(this.state.importParams, this.state.importValues) : null] });
+    };
+    return ZenodoImportUI;
+}(base_1.CollapsableControls));
+exports.ZenodoImportUI = ZenodoImportUI;

package/lib/commonjs/mol-canvas3d/camera/stereo.js

@@ -25,7 +25,7 @@ var StereoCamera = /** @class */ (function () {
         this.parent = parent;
         this.left = new EyeCamera();
         this.right = new EyeCamera();
-        this.props = (0, tslib_1.__assign)((0, tslib_1.__assign)({}, exports.DefaultStereoCameraProps), props);
+        this.props = tslib_1.__assign(tslib_1.__assign({}, exports.DefaultStereoCameraProps), props);
     }
     Object.defineProperty(StereoCamera.prototype, "viewport", {
         get: function () {

package/lib/commonjs/mol-canvas3d/camera/util.js

@@ -22,7 +22,7 @@ exports.Viewport = Viewport;
     }
     Viewport.create = create;
     function clone(viewport) {
-        return (0, tslib_1.__assign)({}, viewport);
+        return tslib_1.__assign({}, viewport);
     }
     Viewport.clone = clone;
     function copy(target, source) {

package/lib/commonjs/mol-canvas3d/camera.js

@@ -11,6 +11,7 @@ var linear_algebra_1 = require("../mol-math/linear-algebra");
 var util_1 = require("./camera/util");
 var transition_1 = require("./camera/transition");
 var rxjs_1 = require("rxjs");
+var type_helpers_1 = require("../mol-util/type-helpers");
 var tmpPos1 = (0, linear_algebra_1.Vec3)();
 var tmpPos2 = (0, linear_algebra_1.Vec3)();
 var tmpClip = (0, linear_algebra_1.Vec4)();
@@ -80,7 +81,7 @@ var Camera = /** @class */ (function () {
             case 'perspective':
                 updatePers(this);
                 break;
-            default: throw new Error('unknown camera mode');
+            default: (0, type_helpers_1.assertUnreachable)(this.state.mode);
         }
         var changed = !linear_algebra_1.Mat4.areEqual(this.projection, this.prevProjection, linear_algebra_1.EPSILON) || !linear_algebra_1.Mat4.areEqual(this.view, this.prevView, linear_algebra_1.EPSILON);
         if (changed) {

package/lib/commonjs/mol-canvas3d/canvas3d.js

@@ -102,7 +102,7 @@ var Canvas3DContext;
     };
     function fromCanvas(canvas, attribs) {
         if (attribs === void 0) { attribs = {}; }
-        var a = (0, tslib_1.__assign)((0, tslib_1.__assign)({}, Canvas3DContext.DefaultAttribs), attribs);
+        var a = tslib_1.__assign(tslib_1.__assign({}, Canvas3DContext.DefaultAttribs), attribs);
         var antialias = a.antialias, preserveDrawingBuffer = a.preserveDrawingBuffer, pixelScale = a.pixelScale, preferWebGl1 = a.preferWebGl1;
         var gl = (0, context_1.getGLContext)(canvas, {
             antialias: antialias,
@@ -190,7 +190,7 @@ var Canvas3D;
     function create(_a, props) {
         var webgl = _a.webgl, input = _a.input, passes = _a.passes, attribs = _a.attribs;
         if (props === void 0) { props = {}; }
-        var p = (0, tslib_1.__assign)((0, tslib_1.__assign)({}, exports.DefaultCanvas3DParams), props);
+        var p = tslib_1.__assign(tslib_1.__assign({}, exports.DefaultCanvas3DParams), props);
         var reprRenderObjects = new Map();
         var reprUpdatedSubscriptions = new Map();
         var reprCount = new rxjs_1.BehaviorSubject(0);
@@ -397,8 +397,8 @@ var Canvas3D;
                 var duration = nextCameraResetDuration === undefined ? p.cameraResetDurationMs : nextCameraResetDuration;
                 var focus_1 = camera.getFocus(center, radius);
                 var next = typeof nextCameraResetSnapshot === 'function' ? nextCameraResetSnapshot(scene, camera) : nextCameraResetSnapshot;
-                var snapshot = next ? (0, tslib_1.__assign)((0, tslib_1.__assign)({}, focus_1), next) : focus_1;
-                camera.setState((0, tslib_1.__assign)((0, tslib_1.__assign)({}, snapshot), { radiusMax: scene.boundingSphere.radius }), duration);
+                var snapshot = next ? tslib_1.__assign(tslib_1.__assign({}, focus_1), next) : focus_1;
+                camera.setState(tslib_1.__assign(tslib_1.__assign({}, snapshot), { radiusMax: scene.boundingSphere.radius }), duration);
             }
             nextCameraResetDuration = void 0;
             nextCameraResetSnapshot = void 0;
@@ -522,8 +522,8 @@ var Canvas3D;
             return {
                 camera: {
                     mode: camera.state.mode,
-                    helper: (0, tslib_1.__assign)({}, helper.camera.props),
-                    stereo: (0, tslib_1.__assign)({}, p.camera.stereo),
+                    helper: tslib_1.__assign({}, helper.camera.props),
+                    stereo: tslib_1.__assign({}, p.camera.stereo),
                     manualReset: !!p.camera.manualReset
                 },
                 cameraFog: camera.state.fog > 0
@@ -533,14 +533,14 @@ var Canvas3D;
                 cameraResetDurationMs: p.cameraResetDurationMs,
                 transparentBackground: p.transparentBackground,
                 viewport: p.viewport,
-                postprocessing: (0, tslib_1.__assign)({}, p.postprocessing),
-                marking: (0, tslib_1.__assign)({}, p.marking),
-                multiSample: (0, tslib_1.__assign)({}, p.multiSample),
-                renderer: (0, tslib_1.__assign)({}, renderer.props),
-                trackball: (0, tslib_1.__assign)({}, controls.props),
-                interaction: (0, tslib_1.__assign)({}, interactionHelper.props),
-                debug: (0, tslib_1.__assign)({}, helper.debug.props),
-                handle: (0, tslib_1.__assign)({}, helper.handle.props),
+                postprocessing: tslib_1.__assign({}, p.postprocessing),
+                marking: tslib_1.__assign({}, p.marking),
+                multiSample: tslib_1.__assign({}, p.multiSample),
+                renderer: tslib_1.__assign({}, renderer.props),
+                trackball: tslib_1.__assign({}, controls.props),
+                interaction: tslib_1.__assign({}, interactionHelper.props),
+                debug: tslib_1.__assign({}, helper.debug.props),
+                handle: tslib_1.__assign({}, helper.handle.props),
             };
         }
         var contextRestoredSub = contextRestored.subscribe(function () {

package/lib/commonjs/mol-canvas3d/controls/trackball.js

@@ -71,7 +71,7 @@ var TrackballControls;
 (function (TrackballControls) {
     function create(input, camera, props) {
         if (props === void 0) { props = {}; }
-        var p = (0, tslib_1.__assign)((0, tslib_1.__assign)({}, param_definition_1.ParamDefinition.getDefaultValues(exports.TrackballControlsParams)), props);
+        var p = tslib_1.__assign(tslib_1.__assign({}, param_definition_1.ParamDefinition.getDefaultValues(exports.TrackballControlsParams)), props);
         var viewport = util_1.Viewport.clone(camera.viewport);
         var disposed = false;
         var dragSub = input.drag.subscribe(onDrag);

package/lib/commonjs/mol-canvas3d/helper/bounding-sphere-helper.js

@@ -31,7 +31,7 @@ var BoundingSphereHelper = /** @class */ (function () {
         this.instancesData = new Map();
         this.scene = scene_1.Scene.create(ctx, render_item_1.GraphicsRenderVariantsBlended);
         this.parent = parent;
-        this._props = (0, tslib_1.__assign)((0, tslib_1.__assign)({}, param_definition_1.ParamDefinition.getDefaultValues(exports.DebugHelperParams)), props);
+        this._props = tslib_1.__assign(tslib_1.__assign({}, param_definition_1.ParamDefinition.getDefaultValues(exports.DebugHelperParams)), props);
     }
     BoundingSphereHelper.prototype.update = function () {
         var _this = this;

package/lib/commonjs/mol-canvas3d/helper/camera-helper.js

@@ -7,7 +7,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.isCameraAxesLoci = exports.CameraHelper = exports.CameraHelperParams = void 0;
 var tslib_1 = require("tslib");
-var immer_1 = (0, tslib_1.__importDefault)(require("immer"));
+var immer_1 = tslib_1.__importDefault(require("immer"));
 var interval_1 = require("../../mol-data/int/interval");
 var cylinder_1 = require("../../mol-geo/geometry/mesh/builder/cylinder");
 var sphere_1 = require("../../mol-geo/geometry/mesh/builder/sphere");
@@ -25,7 +25,7 @@ var marker_action_1 = require("../../mol-util/marker-action");
 var param_definition_1 = require("../../mol-util/param-definition");
 var camera_1 = require("../camera");
 // TODO add scale line/grid
-var AxesParams = (0, tslib_1.__assign)((0, tslib_1.__assign)({}, mesh_1.Mesh.Params), { alpha: (0, tslib_1.__assign)((0, tslib_1.__assign)({}, mesh_1.Mesh.Params.alpha), { defaultValue: 0.51 }), ignoreLight: (0, tslib_1.__assign)((0, tslib_1.__assign)({}, mesh_1.Mesh.Params.ignoreLight), { defaultValue: true }), colorX: param_definition_1.ParamDefinition.Color(names_1.ColorNames.red, { isEssential: true }), colorY: param_definition_1.ParamDefinition.Color(names_1.ColorNames.green, { isEssential: true }), colorZ: param_definition_1.ParamDefinition.Color(names_1.ColorNames.blue, { isEssential: true }), scale: param_definition_1.ParamDefinition.Numeric(0.33, { min: 0.1, max: 2, step: 0.1 }, { isEssential: true }) });
+var AxesParams = tslib_1.__assign(tslib_1.__assign({}, mesh_1.Mesh.Params), { alpha: tslib_1.__assign(tslib_1.__assign({}, mesh_1.Mesh.Params.alpha), { defaultValue: 0.51 }), ignoreLight: tslib_1.__assign(tslib_1.__assign({}, mesh_1.Mesh.Params.ignoreLight), { defaultValue: true }), colorX: param_definition_1.ParamDefinition.Color(names_1.ColorNames.red, { isEssential: true }), colorY: param_definition_1.ParamDefinition.Color(names_1.ColorNames.green, { isEssential: true }), colorZ: param_definition_1.ParamDefinition.Color(names_1.ColorNames.blue, { isEssential: true }), scale: param_definition_1.ParamDefinition.Numeric(0.33, { min: 0.1, max: 2, step: 0.1 }, { isEssential: true }) });
 exports.CameraHelperParams = {
     axes: param_definition_1.ParamDefinition.MappedStatic('on', {
         on: param_definition_1.ParamDefinition.Group(AxesParams),
@@ -34,8 +34,8 @@ exports.CameraHelperParams = {
 };
 var CameraHelper = /** @class */ (function () {
     function CameraHelper(webgl, props) {
-        var _this = this;
         if (props === void 0) { props = {}; }
+        var _this = this;
         this.webgl = webgl;
         this.props = {
             axes: { name: 'off', params: {} }
@@ -69,13 +69,13 @@ var CameraHelper = /** @class */ (function () {
                 p.axes.name = props.axes.name;
                 if (props.axes.name === 'on') {
                     _this.scene.clear();
-                    var params = (0, tslib_1.__assign)((0, tslib_1.__assign)({}, props.axes.params), { scale: props.axes.params.scale * _this.webgl.pixelRatio });
+                    var params = tslib_1.__assign(tslib_1.__assign({}, props.axes.params), { scale: props.axes.params.scale * _this.webgl.pixelRatio });
                     _this.renderObject = createAxesRenderObject(params);
                     _this.scene.add(_this.renderObject);
                     _this.scene.commit();
                     linear_algebra_1.Vec3.set(_this.camera.position, 0, 0, params.scale * 200);
                     linear_algebra_1.Mat4.lookAt(_this.camera.view, _this.camera.position, _this.camera.target, _this.camera.up);
-                    p.axes.params = (0, tslib_1.__assign)({}, props.axes.params);
+                    p.axes.params = tslib_1.__assign({}, props.axes.params);
                 }
             }
         });

package/lib/commonjs/mol-canvas3d/helper/handle-helper.js

@@ -17,14 +17,14 @@ var cylinder_1 = require("../../mol-geo/geometry/mesh/builder/cylinder");
 var mol_util_1 = require("../../mol-util");
 var geometry_1 = require("../../mol-math/geometry");
 var param_definition_1 = require("../../mol-util/param-definition");
-var immer_1 = (0, tslib_1.__importDefault)(require("immer"));
+var immer_1 = tslib_1.__importDefault(require("immer"));
 var shape_1 = require("../../mol-model/shape");
 var loci_1 = require("../../mol-model/loci");
 var marker_action_1 = require("../../mol-util/marker-action");
 var visual_1 = require("../../mol-repr/visual");
 var int_1 = require("../../mol-data/int");
 var render_item_1 = require("../../mol-gl/webgl/render-item");
-var HandleParams = (0, tslib_1.__assign)((0, tslib_1.__assign)({}, mesh_1.Mesh.Params), { alpha: (0, tslib_1.__assign)((0, tslib_1.__assign)({}, mesh_1.Mesh.Params.alpha), { defaultValue: 1 }), ignoreLight: (0, tslib_1.__assign)((0, tslib_1.__assign)({}, mesh_1.Mesh.Params.ignoreLight), { defaultValue: true }), colorX: param_definition_1.ParamDefinition.Color(names_1.ColorNames.red, { isEssential: true }), colorY: param_definition_1.ParamDefinition.Color(names_1.ColorNames.green, { isEssential: true }), colorZ: param_definition_1.ParamDefinition.Color(names_1.ColorNames.blue, { isEssential: true }), scale: param_definition_1.ParamDefinition.Numeric(0.33, { min: 0.1, max: 2, step: 0.1 }, { isEssential: true }) });
+var HandleParams = tslib_1.__assign(tslib_1.__assign({}, mesh_1.Mesh.Params), { alpha: tslib_1.__assign(tslib_1.__assign({}, mesh_1.Mesh.Params.alpha), { defaultValue: 1 }), ignoreLight: tslib_1.__assign(tslib_1.__assign({}, mesh_1.Mesh.Params.ignoreLight), { defaultValue: true }), colorX: param_definition_1.ParamDefinition.Color(names_1.ColorNames.red, { isEssential: true }), colorY: param_definition_1.ParamDefinition.Color(names_1.ColorNames.green, { isEssential: true }), colorZ: param_definition_1.ParamDefinition.Color(names_1.ColorNames.blue, { isEssential: true }), scale: param_definition_1.ParamDefinition.Numeric(0.33, { min: 0.1, max: 2, step: 0.1 }, { isEssential: true }) });
 exports.HandleHelperParams = {
     handle: param_definition_1.ParamDefinition.MappedStatic('off', {
         on: param_definition_1.ParamDefinition.Group(HandleParams),
@@ -33,8 +33,8 @@ exports.HandleHelperParams = {
 };
 var HandleHelper = /** @class */ (function () {
     function HandleHelper(webgl, props) {
-        var _this = this;
         if (props === void 0) { props = {}; }
+        var _this = this;
         this.webgl = webgl;
         this.props = {
             handle: { name: 'off', params: {} }
@@ -74,11 +74,11 @@ var HandleHelper = /** @class */ (function () {
                 p.handle.name = props.handle.name;
                 if (props.handle.name === 'on') {
                     _this.scene.clear();
-                    var params = (0, tslib_1.__assign)((0, tslib_1.__assign)({}, props.handle.params), { scale: props.handle.params.scale * _this.webgl.pixelRatio });
+                    var params = tslib_1.__assign(tslib_1.__assign({}, props.handle.params), { scale: props.handle.params.scale * _this.webgl.pixelRatio });
                     _this.renderObject = createHandleRenderObject(params);
                     _this.scene.add(_this.renderObject);
                     _this.scene.commit();
-                    p.handle.params = (0, tslib_1.__assign)({}, props.handle.params);
+                    p.handle.params = tslib_1.__assign({}, props.handle.params);
                 }
             }
         });

package/lib/commonjs/mol-canvas3d/helper/helper.js

@@ -22,7 +22,7 @@ exports.DefaultHelperProps = param_definition_1.ParamDefinition.getDefaultValues
 var Helper = /** @class */ (function () {
     function Helper(webgl, scene, props) {
         if (props === void 0) { props = {}; }
-        var p = (0, tslib_1.__assign)((0, tslib_1.__assign)({}, exports.DefaultHelperProps), props);
+        var p = tslib_1.__assign(tslib_1.__assign({}, exports.DefaultHelperProps), props);
         this.debug = new bounding_sphere_helper_1.BoundingSphereHelper(webgl, scene, p.debug);
         this.camera = new camera_helper_1.CameraHelper(webgl, p.camera.helper);
         this.handle = new handle_helper_1.HandleHelper(webgl, p.handle);

package/lib/commonjs/mol-canvas3d/helper/interaction-events.js

@@ -23,8 +23,8 @@ exports.Canvas3dInteractionHelperParams = {
 };
 var Canvas3dInteractionHelper = /** @class */ (function () {
     function Canvas3dInteractionHelper(canvasIdentify, lociGetter, input, camera, props) {
-        var _this = this;
         if (props === void 0) { props = {}; }
+        var _this = this;
         this.canvasIdentify = canvasIdentify;
         this.lociGetter = lociGetter;
         this.input = input;
@@ -49,7 +49,7 @@ var Canvas3dInteractionHelper = /** @class */ (function () {
         this.buttons = input_observer_1.ButtonsType.create(0);
         this.button = input_observer_1.ButtonsType.create(0);
         this.modifiers = input_observer_1.ModifiersKeys.None;
-        this.props = (0, tslib_1.__assign)((0, tslib_1.__assign)({}, param_definition_1.ParamDefinition.getDefaultValues(exports.Canvas3dInteractionHelperParams)), props);
+        this.props = tslib_1.__assign(tslib_1.__assign({}, param_definition_1.ParamDefinition.getDefaultValues(exports.Canvas3dInteractionHelperParams)), props);
         input.drag.subscribe(function (_a) {
             var x = _a.x, y = _a.y, buttons = _a.buttons, button = _a.button, modifiers = _a.modifiers;
             _this.isInteracting = true;

package/lib/commonjs/mol-canvas3d/passes/draw.js

@@ -23,11 +23,11 @@ var wboit_1 = require("./wboit");
 var postprocessing_1 = require("./postprocessing");
 var marking_1 = require("./marking");
 var util_2 = require("../../mol-gl/compute/util");
-var DepthMergeSchema = (0, tslib_1.__assign)((0, tslib_1.__assign)({}, util_1.QuadSchema), { tDepthPrimitives: (0, schema_1.TextureSpec)('texture', 'depth', 'ushort', 'nearest'), tDepthVolumes: (0, schema_1.TextureSpec)('texture', 'depth', 'ushort', 'nearest'), uTexSize: (0, schema_1.UniformSpec)('v2'), dPackedDepth: (0, schema_1.DefineSpec)('boolean') });
+var DepthMergeSchema = tslib_1.__assign(tslib_1.__assign({}, util_1.QuadSchema), { tDepthPrimitives: (0, schema_1.TextureSpec)('texture', 'depth', 'ushort', 'nearest'), tDepthVolumes: (0, schema_1.TextureSpec)('texture', 'depth', 'ushort', 'nearest'), uTexSize: (0, schema_1.UniformSpec)('v2'), dPackedDepth: (0, schema_1.DefineSpec)('boolean') });
 var DepthMergeShaderCode = (0, shader_code_1.ShaderCode)('depth-merge', quad_vert_1.quad_vert, depth_merge_frag_1.depthMerge_frag);
 function getDepthMergeRenderable(ctx, depthTexturePrimitives, depthTextureVolumes, packedDepth) {
-    var values = (0, tslib_1.__assign)((0, tslib_1.__assign)({}, util_1.QuadValues), { tDepthPrimitives: mol_util_1.ValueCell.create(depthTexturePrimitives), tDepthVolumes: mol_util_1.ValueCell.create(depthTextureVolumes), uTexSize: mol_util_1.ValueCell.create(linear_algebra_1.Vec2.create(depthTexturePrimitives.getWidth(), depthTexturePrimitives.getHeight())), dPackedDepth: mol_util_1.ValueCell.create(packedDepth) });
-    var schema = (0, tslib_1.__assign)({}, DepthMergeSchema);
+    var values = tslib_1.__assign(tslib_1.__assign({}, util_1.QuadValues), { tDepthPrimitives: mol_util_1.ValueCell.create(depthTexturePrimitives), tDepthVolumes: mol_util_1.ValueCell.create(depthTextureVolumes), uTexSize: mol_util_1.ValueCell.create(linear_algebra_1.Vec2.create(depthTexturePrimitives.getWidth(), depthTexturePrimitives.getHeight())), dPackedDepth: mol_util_1.ValueCell.create(packedDepth) });
+    var schema = tslib_1.__assign({}, DepthMergeSchema);
     var renderItem = (0, render_item_1.createComputeRenderItem)(ctx, 'triangles', DepthMergeShaderCode, schema, values);
     return (0, renderable_1.createComputeRenderable)(renderItem, values);
 }