molstar 4.2.0 → 4.4.0

package/lib/commonjs/extensions/sb-ncbr/tunnels/behavior.d.ts

@@ -0,0 +1,40 @@
+/**
+ * Copyright (c) 2024 mol* contributors, licensed under MIT, See LICENSE file for more info.
+ *
+ * @author Dušan Veľký <dvelky@mail.muni.cz>
+ */
+import { PluginBehavior } from '../../../mol-plugin/behavior';
+import { ParamDefinition as PD } from '../../../mol-util/param-definition';
+import { StructureRepresentationPresetProvider } from '../../../mol-plugin-state/builder/structure/representation-preset';
+import { Structure } from '../../../mol-model/structure';
+export declare const SbNcbrTunnels: import("../../../mol-state").StateTransformer<PluginBehavior.Category, PluginBehavior.Behavior, {
+    autoAttach: boolean;
+}>;
+export declare function isApplicable(structure?: Structure): boolean;
+export declare const TunnelsPreset: StructureRepresentationPresetProvider<{
+    serverType: "pdb";
+    serverUrl: string;
+    ignoreHydrogens: boolean | undefined;
+    ignoreHydrogensVariant: "all" | "non-polar" | undefined;
+    ignoreLight: boolean | undefined;
+    quality: "auto" | "medium" | "high" | "low" | "custom" | "highest" | "higher" | "lower" | "lowest" | undefined;
+    theme: PD.Normalize<{
+        globalName: any;
+        globalColorParams: any;
+        carbonColor: any;
+        symmetryColor: any;
+        symmetryColorParams: any;
+        focus: any;
+    }> | undefined;
+}, {
+    components?: undefined;
+    representations?: undefined;
+} | {
+    components: {
+        polymer: import("../../../mol-state").StateObjectSelector<import("../../../mol-plugin-state/objects").PluginStateObject.Molecule.Structure, import("../../../mol-state").StateTransformer<import("../../../mol-state").StateObject<any, import("../../../mol-state").StateObject.Type<any>>, import("../../../mol-state").StateObject<any, import("../../../mol-state").StateObject.Type<any>>, any>> | undefined;
+    } | {
+        all: import("../../../mol-state").StateObjectSelector<import("../../../mol-plugin-state/objects").PluginStateObject.Molecule.Structure, import("../../../mol-state").StateTransformer<import("../../../mol-state").StateObject<any, import("../../../mol-state").StateObject.Type<any>>, import("../../../mol-state").StateObject<any, import("../../../mol-state").StateObject.Type<any>>, any>> | undefined;
+        branched: undefined;
+    } | undefined;
+    representations: {};
+}>;

package/lib/commonjs/extensions/sb-ncbr/tunnels/behavior.js

@@ -0,0 +1,96 @@
+"use strict";
+/**
+ * Copyright (c) 2024 mol* contributors, licensed under MIT, See LICENSE file for more info.
+ *
+ * @author Dušan Veľký <dvelky@mail.muni.cz>
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TunnelsPreset = exports.SbNcbrTunnels = void 0;
+exports.isApplicable = isApplicable;
+const behavior_1 = require("../../../mol-plugin/behavior");
+const actions_1 = require("./actions");
+const param_definition_1 = require("../../../mol-util/param-definition");
+const representation_preset_1 = require("../../../mol-plugin-state/builder/structure/representation-preset");
+const structure_1 = require("../../../mol-model/structure");
+const mol_state_1 = require("../../../mol-state");
+const props_1 = require("./props");
+const transforms_1 = require("../../../mol-plugin-state/transforms");
+const representation_1 = require("./representation");
+const mesh_utils_1 = require("../../meshes/mesh-utils");
+exports.SbNcbrTunnels = behavior_1.PluginBehavior.create({
+    name: 'sb-ncbr-tunnels',
+    category: 'misc',
+    display: {
+        name: 'SB NCBR Tunnels',
+    },
+    ctor: class extends behavior_1.PluginBehavior.Handler {
+        register() {
+            this.ctx.state.data.actions.add(actions_1.DownloadTunnels);
+            this.ctx.builders.structure.representation.registerPreset(exports.TunnelsPreset);
+        }
+        unregister() {
+            this.ctx.state.data.actions.remove(actions_1.DownloadTunnels);
+            this.ctx.builders.structure.representation.unregisterPreset(exports.TunnelsPreset);
+        }
+    },
+    params: () => ({
+        autoAttach: param_definition_1.ParamDefinition.Boolean(true),
+    })
+});
+function isApplicable(structure) {
+    return (!!structure && structure.models.length === 1 &&
+        structure_1.Model.hasPdbId(structure.models[0]));
+}
+exports.TunnelsPreset = (0, representation_preset_1.StructureRepresentationPresetProvider)({
+    id: 'sb-ncbr-preset-structure-tunnels',
+    display: {
+        name: 'Tunnels', group: 'Annotation',
+        description: 'Shows Tunnels from ChannelsDB contained in the structure.'
+    },
+    isApplicable(a) {
+        return isApplicable(a.data);
+    },
+    params: (a, plugin) => {
+        return {
+            ...representation_preset_1.StructureRepresentationPresetProvider.CommonParams,
+            ...getConfiguredDefaultParams(plugin)
+        };
+    },
+    async apply(ref, params, plugin) {
+        var _a, _b;
+        const structureCell = mol_state_1.StateObjectRef.resolveAndCheck(plugin.state.data, ref);
+        const structure = (_a = structureCell === null || structureCell === void 0 ? void 0 : structureCell.obj) === null || _a === void 0 ? void 0 : _a.data;
+        if (!structureCell || !structure)
+            return {};
+        const update = plugin.build();
+        const webgl = (_b = plugin.canvas3dContext) === null || _b === void 0 ? void 0 : _b.webgl;
+        const response = await (await fetch(`${params.serverUrl}/channels/${params.serverType}/${structure.model.entryId.toLowerCase()}`)).json();
+        const tunnels = [];
+        Object.entries(response.Channels).forEach(([key, values]) => {
+            if (values.length > 0) {
+                values.forEach((item) => {
+                    tunnels.push({ data: item.Profile, props: { id: item.Id, type: item.Type } });
+                });
+            }
+        });
+        await tunnels.forEach(async (tunnel) => {
+            await update
+                .toRoot()
+                .apply(representation_1.TunnelFromRawData, { data: tunnel })
+                .apply(representation_1.TunnelShapeProvider, {
+                webgl,
+                colorTheme: mesh_utils_1.ColorGenerator.next().value,
+            })
+                .apply(transforms_1.StateTransforms.Representation.ShapeRepresentation3D);
+            await update.commit();
+        });
+        const preset = await representation_preset_1.PresetStructureRepresentations.auto.apply(ref, { ...params }, plugin);
+        return { components: preset.components, representations: { ...preset.representations, } };
+    }
+});
+function getConfiguredDefaultParams(plugin) {
+    const config = (0, props_1.getTunnelsConfig)(plugin);
+    const params = param_definition_1.ParamDefinition.clone(props_1.TunnelsDataParams);
+    param_definition_1.ParamDefinition.setDefaultValues(params, { serverType: config.DefaultServerType, serverUrl: config.DefaultServerUrl });
+    return params;
+}

package/lib/commonjs/extensions/sb-ncbr/tunnels/data-model.d.ts

@@ -0,0 +1,146 @@
+/**
+ * Copyright (c) 2024 mol* contributors, licensed under MIT, See LICENSE file for more info.
+ *
+ * @author Dušan Veľký <dvelky@mail.muni.cz>
+ */
+import { WebGLContext } from '../../../mol-gl/webgl/context';
+import { PluginStateObject } from '../../../mol-plugin-state/objects';
+import { ParamDefinition as PD } from '../../../mol-util/param-definition';
+export interface Profile {
+    Charge: number;
+    Radius: number;
+    FreeRadius: number;
+    T: number;
+    Distance: number;
+    X: number;
+    Y: number;
+    Z: number;
+}
+export interface Layerweightedproperties {
+    Hydrophobicity: number;
+    Hydropathy: number;
+    Polarity: number;
+    Mutability: number;
+}
+export interface LayerGeometry {
+    MinRadius: number;
+    MinFreeRadius: number;
+    StartDistance: number;
+    EndDistance: number;
+    LocalMinimum: boolean;
+    Bottleneck: boolean;
+    bottleneck: boolean;
+}
+export interface Properties {
+    Charge: number;
+    NumPositives: number;
+    NumNegatives: number;
+    Hydrophobicity: number;
+    Hydropathy: number;
+    Polarity: number;
+    Mutability: number;
+}
+export interface LayersInfo {
+    LayerGeometry: LayerGeometry;
+    Residues: string[];
+    FlowIndices: string[];
+    Properties: Properties;
+}
+export interface Layers {
+    ResidueFlow: string[];
+    HetResidues: any[];
+    LayerWeightedProperties: Layerweightedproperties;
+    LayersInfo: LayersInfo[];
+}
+export interface TunnelDB {
+    Type: string;
+    Id: string;
+    Cavity: string;
+    Auto: boolean;
+    Properties: Properties;
+    Profile: Profile[];
+    Layers: Layers;
+}
+export interface ChannelsDBdata {
+    'CSATunnels_MOLE': TunnelDB[];
+    'CSATunnels_Caver': TunnelDB[];
+    'ReviewedChannels_MOLE': TunnelDB[];
+    'ReviewedChannels_Caver': TunnelDB[];
+    'CofactorTunnels_MOLE': TunnelDB[];
+    'CofactorTunnels_Caver': TunnelDB[];
+    'TransmembranePores_MOLE': TunnelDB[];
+    'TransmembranePores_Caver': TunnelDB[];
+    'ProcognateTunnels_MOLE': TunnelDB[];
+    'ProcognateTunnels_Caver': TunnelDB[];
+    'AlphaFillTunnels_MOLE': TunnelDB[];
+    'AlphaFillTunnels_Caver': TunnelDB[];
+}
+export interface ChannelsCache {
+    Channels: ChannelsDBdata;
+}
+export interface Tunnel {
+    data: Profile[];
+    props: {
+        highlight_label?: string;
+        type?: string;
+        id?: string;
+        label?: string;
+        description?: string;
+    };
+}
+export declare const TunnelShapeParams: {
+    webgl: PD.Value<WebGLContext | null>;
+    colorTheme: PD.Color;
+    visual: PD.Mapped<PD.NamedParams<PD.Normalize<{
+        resolution: number;
+    }>, "spheres"> | PD.NamedParams<PD.Normalize<{
+        resolution: number;
+    }>, "mesh">>;
+    samplingRate: PD.Numeric;
+    showRadii: PD.BooleanParam;
+};
+declare const TunnelStateObject_base: {
+    new (data: {
+        tunnel: Tunnel;
+    }, props?: {
+        label: string;
+        description?: string;
+    } | undefined): {
+        id: import("../../../mol-util").UUID;
+        type: PluginStateObject.TypeInfo;
+        label: string;
+        description?: string;
+        data: {
+            tunnel: Tunnel;
+        };
+    };
+    type: PluginStateObject.TypeInfo;
+    is(obj?: import("../../../mol-state").StateObject): obj is import("../../../mol-state").StateObject<{
+        tunnel: Tunnel;
+    }, PluginStateObject.TypeInfo>;
+};
+export declare class TunnelStateObject extends TunnelStateObject_base {
+}
+declare const TunnelsStateObject_base: {
+    new (data: {
+        tunnels: Tunnel[];
+    }, props?: {
+        label: string;
+        description?: string;
+    } | undefined): {
+        id: import("../../../mol-util").UUID;
+        type: PluginStateObject.TypeInfo;
+        label: string;
+        description?: string;
+        data: {
+            tunnels: Tunnel[];
+        };
+    };
+    type: PluginStateObject.TypeInfo;
+    is(obj?: import("../../../mol-state").StateObject): obj is import("../../../mol-state").StateObject<{
+        tunnels: Tunnel[];
+    }, PluginStateObject.TypeInfo>;
+};
+export declare class TunnelsStateObject extends TunnelsStateObject_base {
+}
+export {};

package/lib/commonjs/extensions/sb-ncbr/tunnels/data-model.js

@@ -0,0 +1,28 @@
+"use strict";
+/**
+ * Copyright (c) 2024 mol* contributors, licensed under MIT, See LICENSE file for more info.
+ *
+ * @author Dušan Veľký <dvelky@mail.muni.cz>
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TunnelsStateObject = exports.TunnelStateObject = exports.TunnelShapeParams = void 0;
+const objects_1 = require("../../../mol-plugin-state/objects");
+const color_1 = require("../../../mol-util/color");
+const param_definition_1 = require("../../../mol-util/param-definition");
+;
+exports.TunnelShapeParams = {
+    webgl: param_definition_1.ParamDefinition.Value(null),
+    colorTheme: param_definition_1.ParamDefinition.Color((0, color_1.Color)(0xff0000)),
+    visual: param_definition_1.ParamDefinition.MappedStatic('mesh', {
+        mesh: param_definition_1.ParamDefinition.Group({ resolution: param_definition_1.ParamDefinition.Numeric(2) }),
+        spheres: param_definition_1.ParamDefinition.Group({ resolution: param_definition_1.ParamDefinition.Numeric(2) })
+    }),
+    samplingRate: param_definition_1.ParamDefinition.Numeric(1, { min: 0.05, max: 1, step: 0.05 }),
+    showRadii: param_definition_1.ParamDefinition.Boolean(false),
+};
+class TunnelStateObject extends objects_1.PluginStateObject.Create({ name: 'Tunnel Entry', typeClass: 'Data' }) {
+}
+exports.TunnelStateObject = TunnelStateObject;
+class TunnelsStateObject extends objects_1.PluginStateObject.Create({ name: 'Tunnels', typeClass: 'Data' }) {
+}
+exports.TunnelsStateObject = TunnelsStateObject;

package/lib/commonjs/extensions/sb-ncbr/tunnels/examples.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Copyright (c) 2024 mol* contributors, licensed under MIT, See LICENSE file for more info.
+ *
+ * @author Dušan Veľký <dvelky@mail.muni.cz>
+ */
+import { PluginContext } from '../../../mol-plugin/context';
+export declare const DB_URL = "https://channelsdb2.biodata.ceitec.cz/api/channels/";
+export declare const SUB_DB = "pdb";
+export declare const CHANNEL = "1ymg";
+export declare const URL = "https://channelsdb2.biodata.ceitec.cz/api/channels/pdb/1ymg";
+export declare function runVisualizeTunnels(plugin: PluginContext, url?: string): Promise<void>;
+export declare function runVisualizeTunnel(plugin: PluginContext): Promise<void>;

package/lib/commonjs/extensions/sb-ncbr/tunnels/examples.js

@@ -0,0 +1,54 @@
+"use strict";
+/**
+ * Copyright (c) 2024 mol* contributors, licensed under MIT, See LICENSE file for more info.
+ *
+ * @author Dušan Veľký <dvelky@mail.muni.cz>
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.URL = exports.CHANNEL = exports.SUB_DB = exports.DB_URL = void 0;
+exports.runVisualizeTunnels = runVisualizeTunnels;
+exports.runVisualizeTunnel = runVisualizeTunnel;
+const transforms_1 = require("../../../mol-plugin-state/transforms");
+const representation_1 = require("./representation");
+exports.DB_URL = 'https://channelsdb2.biodata.ceitec.cz/api/channels/';
+exports.SUB_DB = 'pdb';
+exports.CHANNEL = '1ymg';
+exports.URL = `${exports.DB_URL}${exports.SUB_DB}/${exports.CHANNEL}`;
+async function runVisualizeTunnels(plugin, url = exports.URL) {
+    var _a;
+    const update = plugin.build();
+    const webgl = (_a = plugin.canvas3dContext) === null || _a === void 0 ? void 0 : _a.webgl;
+    const response = await (await fetch(url)).json();
+    const tunnels = [];
+    Object.entries(response.Channels).forEach(([key, values]) => {
+        if (values.length > 0) {
+            values.forEach((item) => {
+                tunnels.push({ data: item.Profile, props: { id: item.Id, type: item.Type } });
+            });
+        }
+    });
+    update
+        .toRoot()
+        .apply(representation_1.TunnelsFromRawData, { data: tunnels })
+        .apply(representation_1.SelectTunnel)
+        .apply(representation_1.TunnelShapeProvider, {
+        webgl,
+    })
+        .apply(transforms_1.StateTransforms.Representation.ShapeRepresentation3D);
+    await update.commit();
+}
+async function runVisualizeTunnel(plugin) {
+    var _a;
+    const update = plugin.build();
+    const webgl = (_a = plugin.canvas3dContext) === null || _a === void 0 ? void 0 : _a.webgl;
+    const response = await (await fetch(exports.URL)).json();
+    const tunnel = response.Channels.TransmembranePores_MOLE[0];
+    update
+        .toRoot()
+        .apply(representation_1.TunnelFromRawData, { data: { data: tunnel.Profile, props: { id: tunnel.Id, type: tunnel.Type } } })
+        .apply(representation_1.TunnelShapeProvider, {
+        webgl,
+    })
+        .apply(transforms_1.StateTransforms.Representation.ShapeRepresentation3D);
+    await update.commit();
+}

package/lib/commonjs/extensions/sb-ncbr/tunnels/props.d.ts

@@ -0,0 +1,19 @@
+import { PluginConfigItem } from '../../../mol-plugin/config';
+import { PluginContext } from '../../../mol-plugin/context';
+import { ParamDefinition as PD } from '../../../mol-util/param-definition';
+export declare namespace TunnelsData {
+    const DefaultServerUrl = "https://channelsdb2.biodata.ceitec.cz/api";
+    const DefaultServerType = "pdb";
+}
+export declare const TunnelsDataParams: {
+    serverType: PD.Select<"pdb">;
+    serverUrl: PD.Text<string>;
+};
+export type TunnelsDataParams = typeof TunnelsDataParams;
+export declare const TunnelsServerConfig: {
+    DefaultServerUrl: PluginConfigItem<string>;
+    DefaultServerType: PluginConfigItem<"pdb">;
+};
+export declare function getTunnelsConfig(plugin: PluginContext): {
+    [key in keyof typeof TunnelsServerConfig]: NonNullable<typeof TunnelsServerConfig[key]['defaultValue']>;
+};

package/lib/commonjs/extensions/sb-ncbr/tunnels/props.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TunnelsServerConfig = exports.TunnelsDataParams = exports.TunnelsData = void 0;
+exports.getTunnelsConfig = getTunnelsConfig;
+const config_1 = require("../../../mol-plugin/config");
+const param_definition_1 = require("../../../mol-util/param-definition");
+var TunnelsData;
+(function (TunnelsData) {
+    TunnelsData.DefaultServerUrl = 'https://channelsdb2.biodata.ceitec.cz/api';
+    TunnelsData.DefaultServerType = 'pdb';
+})(TunnelsData || (exports.TunnelsData = TunnelsData = {}));
+exports.TunnelsDataParams = {
+    serverType: param_definition_1.ParamDefinition.Select('pdb', [['pdb', 'pdb']]),
+    serverUrl: param_definition_1.ParamDefinition.Text(TunnelsData.DefaultServerUrl)
+};
+exports.TunnelsServerConfig = {
+    DefaultServerUrl: new config_1.PluginConfigItem('channelsdb-server', 'https://channelsdb2.biodata.ceitec.cz/api'),
+    DefaultServerType: new config_1.PluginConfigItem('serverType', 'pdb')
+};
+function getTunnelsConfig(plugin) {
+    var _a, _b, _c, _d;
+    return {
+        DefaultServerUrl: (_b = (_a = plugin.config.get(exports.TunnelsServerConfig.DefaultServerUrl)) !== null && _a !== void 0 ? _a : exports.TunnelsServerConfig.DefaultServerUrl.defaultValue) !== null && _b !== void 0 ? _b : TunnelsData.DefaultServerUrl,
+        DefaultServerType: (_d = (_c = plugin.config.get(exports.TunnelsServerConfig.DefaultServerType)) !== null && _c !== void 0 ? _c : exports.TunnelsServerConfig.DefaultServerType.defaultValue) !== null && _d !== void 0 ? _d : TunnelsData.DefaultServerType,
+    };
+}

package/lib/commonjs/extensions/sb-ncbr/tunnels/representation.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Copyright (c) 2024 mol* contributors, licensed under MIT, See LICENSE file for more info.
+ *
+ * @author Dušan Veľký <dvelky@mail.muni.cz>
+ */
+import { PluginStateObject } from '../../../mol-plugin-state/objects';
+import { StateTransformer } from '../../../mol-state';
+import { TunnelStateObject, Tunnel, TunnelsStateObject } from './data-model';
+import { ParamDefinition as PD } from '../../../mol-util/param-definition';
+export declare const TunnelsFromRawData: StateTransformer<PluginStateObject.Root, TunnelsStateObject, PD.Normalize<{
+    data: Tunnel[];
+}>>;
+export declare const SelectTunnel: StateTransformer<TunnelsStateObject, TunnelStateObject, PD.Normalize<{
+    index: number;
+}>>;
+export declare const TunnelFromRawData: StateTransformer<PluginStateObject.Root, TunnelStateObject, PD.Normalize<{
+    data: Tunnel;
+}>>;
+export declare const TunnelShapeProvider: StateTransformer<TunnelStateObject, PluginStateObject.Shape.Provider, PD.Normalize<{
+    webgl: import("../../../mol-gl/webgl/context").WebGLContext | null;
+    colorTheme: import("../../../mol-util/color").Color;
+    visual: PD.NamedParams<PD.Normalize<{
+        resolution: any;
+    }>, "spheres"> | PD.NamedParams<PD.Normalize<{
+        resolution: any;
+    }>, "mesh">;
+    samplingRate: number;
+    showRadii: boolean;
+}>>;

package/lib/commonjs/extensions/sb-ncbr/tunnels/representation.js

@@ -0,0 +1,99 @@
+"use strict";
+/**
+ * Copyright (c) 2024 mol* contributors, licensed under MIT, See LICENSE file for more info.
+ *
+ * @author Dušan Veľký <dvelky@mail.muni.cz>
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TunnelShapeProvider = exports.TunnelFromRawData = exports.SelectTunnel = exports.TunnelsFromRawData = void 0;
+const objects_1 = require("../../../mol-plugin-state/objects");
+const mol_state_1 = require("../../../mol-state");
+const data_model_1 = require("./data-model");
+const param_definition_1 = require("../../../mol-util/param-definition");
+const mesh_1 = require("../../../mol-geo/geometry/mesh/mesh");
+const mol_task_1 = require("../../../mol-task");
+const algorithm_1 = require("./algorithm");
+const Transform = mol_state_1.StateTransformer.builderFactory('sb-ncbr-tunnels');
+exports.TunnelsFromRawData = Transform({
+    name: 'sb-ncbr-tunnels-from-data',
+    display: { name: 'Tunnels' },
+    from: objects_1.PluginStateObject.Root,
+    to: data_model_1.TunnelsStateObject,
+    params: {
+        data: param_definition_1.ParamDefinition.Value([]),
+    },
+})({
+    apply({ params }) {
+        return new data_model_1.TunnelsStateObject({ tunnels: params.data });
+    },
+});
+exports.SelectTunnel = Transform({
+    name: 'sb-ncbr-tunnel-from-tunnels',
+    display: { name: 'Tunnel Selection' },
+    from: data_model_1.TunnelsStateObject,
+    to: data_model_1.TunnelStateObject,
+    params: a => {
+        return {
+            index: param_definition_1.ParamDefinition.Numeric(0, { min: 0, max: a.data.tunnels.length - 1, step: 1 })
+        };
+    }
+})({
+    apply({ a, params }) {
+        return new data_model_1.TunnelStateObject({ tunnel: a.data.tunnels[params.index] });
+    }
+});
+exports.TunnelFromRawData = Transform({
+    name: 'sb-ncbr-tunnel-from-data',
+    display: { name: 'Tunnel Entry' },
+    from: objects_1.PluginStateObject.Root,
+    to: data_model_1.TunnelStateObject,
+    params: {
+        data: param_definition_1.ParamDefinition.Value(undefined, { isHidden: true })
+    },
+})({
+    apply({ params }) {
+        return new data_model_1.TunnelStateObject({ tunnel: params.data });
+    },
+});
+exports.TunnelShapeProvider = Transform({
+    name: 'sb-ncbr-tunnel-shape-provider',
+    display: { name: 'Tunnel' },
+    from: data_model_1.TunnelStateObject,
+    to: objects_1.PluginStateObject.Shape.Provider,
+    params: a => { return data_model_1.TunnelShapeParams; },
+})({
+    apply({ a, params }) {
+        return mol_task_1.Task.create('Tunnel Shape Representation', async (ctx) => {
+            var _a, _b;
+            return new objects_1.PluginStateObject.Shape.Provider({
+                label: 'Surface',
+                data: { params, data: a.data },
+                params: mesh_1.Mesh.Params,
+                geometryUtils: mesh_1.Mesh.Utils,
+                getShape: (_, data, __, mesh) => {
+                    if (data.params.visual.name === 'mesh' && !data.params.showRadii) {
+                        return (0, algorithm_1.createTunnelShape)({
+                            tunnel: data.data.tunnel,
+                            color: data.params.colorTheme,
+                            resolution: data.params.visual.params.resolution,
+                            sampleRate: data.params.samplingRate,
+                            webgl: data.params.webgl, prev: mesh
+                        });
+                    }
+                    return (0, algorithm_1.createSpheresShape)({
+                        tunnel: data.data.tunnel,
+                        color: data.params.colorTheme,
+                        resolution: data.params.visual.params.resolution,
+                        sampleRate: data.params.samplingRate,
+                        showRadii: data.params.showRadii, prev: mesh
+                    });
+                }
+            }, {
+                label: (_a = a.data.tunnel.props.label) !== null && _a !== void 0 ? _a : 'Tunnel',
+                description: ((_b = a.data.tunnel.props.description) !== null && _b !== void 0 ? _b : (a.data.tunnel.props.type && a.data.tunnel.props.id))
+                    ? `${a.data.tunnel.props.type} ${a.data.tunnel.props.id}`
+                    : '',
+            });
+        });
+    },
+});

package/lib/commonjs/extensions/volumes-and-segmentations/entry-root.d.ts

@@ -37,16 +37,16 @@ export declare namespace VolsegEntryParamValues {
 declare const VolsegEntry_base: {
     new (data: VolsegEntryData, props?: {
         label: string;
-        description?: string | undefined;
+        description?: string;
     } | undefined): {
         id: import("../../mol-util").UUID;
         type: PluginStateObject.TypeInfo;
         label: string;
-        description?: string | undefined;
+        description?: string;
         data: VolsegEntryData;
     };
     type: PluginStateObject.TypeInfo;
-    is(obj?: import("../../mol-state").StateObject<any, import("../../mol-state").StateObject.Type<any>> | undefined): obj is import("../../mol-state").StateObject<VolsegEntryData, PluginStateObject.TypeInfo>;
+    is(obj?: import("../../mol-state").StateObject): obj is import("../../mol-state").StateObject<VolsegEntryData, PluginStateObject.TypeInfo>;
 };
 export declare class VolsegEntry extends VolsegEntry_base {
 }

package/lib/commonjs/extensions/volumes-and-segmentations/entry-root.js

@@ -5,7 +5,9 @@
  * @author Adam Midlik <midlik@gmail.com>
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.VolsegEntryData = exports.VolsegEntry = exports.VolsegEntryParamValues = exports.createVolsegEntryParams = exports.createLoadVolsegParams = exports.BOX = exports.MAX_VOXELS = void 0;
+exports.VolsegEntryData = exports.VolsegEntry = exports.VolsegEntryParamValues = exports.BOX = exports.MAX_VOXELS = void 0;
+exports.createLoadVolsegParams = createLoadVolsegParams;
+exports.createVolsegEntryParams = createVolsegEntryParams;
 const tslib_1 = require("tslib");
 const rxjs_1 = require("rxjs");
 const _1 = require(".");
@@ -42,7 +44,6 @@ function createLoadVolsegParams(plugin, entrylists = {}) {
         source: param_definition_1.ParamDefinition.Mapped(SourceChoice.values[0], SourceChoice.options, src => entryParam(entrylists[src])),
     };
 }
-exports.createLoadVolsegParams = createLoadVolsegParams;
 function entryParam(entries = []) {
     const options = entries.map(e => [e, e]);
     options.push(['__custom__', 'Custom']);
@@ -60,7 +61,6 @@ function createVolsegEntryParams(plugin) {
         entryId: param_definition_1.ParamDefinition.Text('emd-1832', { description: 'Entry identifier, including the source prefix, e.g. "emd-1832"' }),
     };
 }
-exports.createVolsegEntryParams = createVolsegEntryParams;
 var VolsegEntryParamValues;
 (function (VolsegEntryParamValues) {
     function fromLoadVolsegParamValues(params) {

package/lib/commonjs/extensions/volumes-and-segmentations/entry-state.d.ts

@@ -39,12 +39,12 @@ declare const VolsegState_base: {
         }>>;
     }>, props?: {
         label: string;
-        description?: string | undefined;
+        description?: string;
     } | undefined): {
         id: import("../../mol-util").UUID;
         type: PluginStateObject.TypeInfo;
         label: string;
-        description?: string | undefined;
+        description?: string;
         data: PD.Values<{
             volumeType: PD.Select<"off" | "direct-volume" | "isosurface">;
             volumeIsovalueKind: PD.Select<string>;
@@ -61,7 +61,7 @@ declare const VolsegState_base: {
         }>;
     };
     type: PluginStateObject.TypeInfo;
-    is(obj?: import("../../mol-state").StateObject<any, import("../../mol-state").StateObject.Type<any>> | undefined): obj is import("../../mol-state").StateObject<PD.Values<{
+    is(obj?: import("../../mol-state").StateObject): obj is import("../../mol-state").StateObject<PD.Values<{
         volumeType: PD.Select<"off" | "direct-volume" | "isosurface">;
         volumeIsovalueKind: PD.Select<string>;
         volumeIsovalueValue: PD.Numeric;

package/lib/commonjs/extensions/volumes-and-segmentations/external-api.js

@@ -5,7 +5,8 @@
  * @author Adam Midlik <midlik@gmail.com>
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getPdbIdsForEmdbEntry = exports.tryGetIsovalue = void 0;
+exports.tryGetIsovalue = tryGetIsovalue;
+exports.getPdbIdsForEmdbEntry = getPdbIdsForEmdbEntry;
 const helpers_1 = require("./helpers");
 /** Try to get author-defined contour value for isosurface from EMDB API. Return relative value 1.0, if not applicable or fails.  */
 async function tryGetIsovalue(entryId) {
@@ -29,7 +30,6 @@ async function tryGetIsovalue(entryId) {
     }
     return undefined;
 }
-exports.tryGetIsovalue = tryGetIsovalue;
 async function getPdbIdsForEmdbEntry(entryId) {
     var _a, _b, _c;
     const split = (0, helpers_1.splitEntryId)(entryId);
@@ -54,4 +54,3 @@ async function getPdbIdsForEmdbEntry(entryId) {
     }
     return result;
 }
-exports.getPdbIdsForEmdbEntry = getPdbIdsForEmdbEntry;