molstar 2.3.9 → 3.0.0-dev.10

package/lib/commonjs/mol-repr/volume/slice.d.ts

@@ -15,10 +15,10 @@ export declare const SliceParams: {
     quality: {
         isEssential: boolean;
         type: "select";
-        options: readonly (readonly ["custom" | "auto" | "highest" | "higher" | "high" | "medium" | "low" | "lower" | "lowest", string] | readonly ["custom" | "auto" | "highest" | "higher" | "high" | "medium" | "low" | "lower" | "lowest", string, string | undefined])[];
+        options: readonly (readonly ["auto" | "medium" | "high" | "low" | "custom" | "highest" | "higher" | "lower" | "lowest", string] | readonly ["auto" | "medium" | "high" | "low" | "custom" | "highest" | "higher" | "lower" | "lowest", string, string | undefined])[];
         cycle?: boolean | undefined;
         isOptional?: boolean | undefined;
-        defaultValue: "custom" | "auto" | "highest" | "higher" | "high" | "medium" | "low" | "lower" | "lowest";
+        defaultValue: "auto" | "medium" | "high" | "low" | "custom" | "highest" | "higher" | "lower" | "lowest";
         label?: string | undefined;
         description?: string | undefined;
         legend?: import("../../mol-util/legend").Legend | undefined;
@@ -60,16 +60,31 @@ export declare const SliceParams: {
     }>;
     interpolation: PD.Select<"nearest" | "bspline" | "catmulrom" | "mitchell">;
     alpha: PD.Numeric;
+    material: PD.Group<PD.Normalize<{
+        metalness: number;
+        roughness: number;
+        bumpiness: number;
+    }>>;
+    clip: PD.Group<PD.Normalize<{
+        variant: import("../../mol-util/clip").Clip.Variant;
+        objects: PD.Normalize<{
+            type: any;
+            invert: any;
+            position: any;
+            rotation: any;
+            scale: any;
+        }>[];
+    }>>;
 };
 export declare type SliceParams = typeof SliceParams;
 export declare function getSliceParams(ctx: ThemeRegistryContext, volume: Volume): {
     quality: {
         isEssential: boolean;
         type: "select";
-        options: readonly (readonly ["custom" | "auto" | "highest" | "higher" | "high" | "medium" | "low" | "lower" | "lowest", string] | readonly ["custom" | "auto" | "highest" | "higher" | "high" | "medium" | "low" | "lower" | "lowest", string, string | undefined])[];
+        options: readonly (readonly ["auto" | "medium" | "high" | "low" | "custom" | "highest" | "higher" | "lower" | "lowest", string] | readonly ["auto" | "medium" | "high" | "low" | "custom" | "highest" | "higher" | "lower" | "lowest", string, string | undefined])[];
         cycle?: boolean | undefined;
         isOptional?: boolean | undefined;
-        defaultValue: "custom" | "auto" | "highest" | "higher" | "high" | "medium" | "low" | "lower" | "lowest";
+        defaultValue: "auto" | "medium" | "high" | "low" | "custom" | "highest" | "higher" | "lower" | "lowest";
         label?: string | undefined;
         description?: string | undefined;
         legend?: import("../../mol-util/legend").Legend | undefined;
@@ -111,6 +126,21 @@ export declare function getSliceParams(ctx: ThemeRegistryContext, volume: Volume
     }>;
     interpolation: PD.Select<"nearest" | "bspline" | "catmulrom" | "mitchell">;
     alpha: PD.Numeric;
+    material: PD.Group<PD.Normalize<{
+        metalness: number;
+        roughness: number;
+        bumpiness: number;
+    }>>;
+    clip: PD.Group<PD.Normalize<{
+        variant: import("../../mol-util/clip").Clip.Variant;
+        objects: PD.Normalize<{
+            type: any;
+            invert: any;
+            position: any;
+            rotation: any;
+            scale: any;
+        }>[];
+    }>>;
 };
 export declare function SliceVisual(materialId: number): VolumeVisual<SliceParams>;
 export declare function SliceRepresentation(ctx: RepresentationContext, getParams: RepresentationParamsGetter<Volume, SliceParams>): VolumeRepresentation<SliceParams>;
@@ -118,10 +148,10 @@ export declare const SliceRepresentationProvider: VolumeRepresentationProvider<{
     quality: {
         isEssential: boolean;
         type: "select";
-        options: readonly (readonly ["custom" | "auto" | "highest" | "higher" | "high" | "medium" | "low" | "lower" | "lowest", string] | readonly ["custom" | "auto" | "highest" | "higher" | "high" | "medium" | "low" | "lower" | "lowest", string, string | undefined])[];
+        options: readonly (readonly ["auto" | "medium" | "high" | "low" | "custom" | "highest" | "higher" | "lower" | "lowest", string] | readonly ["auto" | "medium" | "high" | "low" | "custom" | "highest" | "higher" | "lower" | "lowest", string, string | undefined])[];
         cycle?: boolean | undefined;
         isOptional?: boolean | undefined;
-        defaultValue: "custom" | "auto" | "highest" | "higher" | "high" | "medium" | "low" | "lower" | "lowest";
+        defaultValue: "auto" | "medium" | "high" | "low" | "custom" | "highest" | "higher" | "lower" | "lowest";
         label?: string | undefined;
         description?: string | undefined;
         legend?: import("../../mol-util/legend").Legend | undefined;
@@ -163,4 +193,19 @@ export declare const SliceRepresentationProvider: VolumeRepresentationProvider<{
     }>;
     interpolation: PD.Select<"nearest" | "bspline" | "catmulrom" | "mitchell">;
     alpha: PD.Numeric;
+    material: PD.Group<PD.Normalize<{
+        metalness: number;
+        roughness: number;
+        bumpiness: number;
+    }>>;
+    clip: PD.Group<PD.Normalize<{
+        variant: import("../../mol-util/clip").Clip.Variant;
+        objects: PD.Normalize<{
+            type: any;
+            invert: any;
+            position: any;
+            rotation: any;
+            scale: any;
+        }>[];
+    }>>;
 }, "slice">;

package/lib/commonjs/mol-repr/volume/slice.js

@@ -18,7 +18,7 @@ var int_1 = require("../../mol-data/int");
 var util_1 = require("../../mol-geo/util");
 var color_1 = require("../../mol-util/color");
 var color_2 = require("../../mol-theme/color");
-var float_packing_1 = require("../../mol-util/float-packing");
+var number_packing_1 = require("../../mol-util/number-packing");
 var util_2 = require("./util");
 function createImage(ctx, volume, theme, props, image) {
     return (0, tslib_1.__awaiter)(this, void 0, void 0, function () {
@@ -103,7 +103,7 @@ function getPackedGroupArray(grid, props) {
     for (var iy = y0; iy < ny; ++iy) {
         for (var ix = x0; ix < nx; ++ix) {
             for (var iz = z0; iz < nz; ++iz) {
-                (0, float_packing_1.encodeFloatRGBtoArray)(space.dataOffset(ix, iy, iz), groupArray, j);
+                (0, number_packing_1.packIntToRGBArray)(space.dataOffset(ix, iy, iz), groupArray, j);
                 j += 4;
             }
         }

package/lib/commonjs/mol-repr/volume/util.js

@@ -10,7 +10,7 @@ var volume_1 = require("../../mol-model/volume");
 var int_1 = require("../../mol-data/int");
 var common_1 = require("../../mol-math/linear-algebra/3d/common");
 var vec3_1 = require("../../mol-math/linear-algebra/3d/vec3");
-var float_packing_1 = require("../../mol-util/float-packing");
+var number_packing_1 = require("../../mol-util/number-packing");
 // avoiding namespace lookup improved performance in Chrome (Aug 2020)
 var v3set = vec3_1.Vec3.set;
 var v3normalize = vec3_1.Vec3.normalize;
@@ -118,7 +118,7 @@ function createVolumeTexture2d(volume, variant, padding) {
                 }
                 else {
                     if (variant === 'groups') {
-                        (0, float_packing_1.encodeFloatRGBtoArray)(offset, array, index);
+                        (0, number_packing_1.packIntToRGBArray)(offset, array, index);
                     }
                     else {
                         v3set(n0, data[o(Math.max(0, x - 1), y, z)], data[o(x, Math.max(0, y - 1), z)], data[o(x, y, Math.max(0, z - 1))]);

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

@@ -21,7 +21,6 @@ var now_1 = require("../mol-util/now");
 var param_definition_1 = require("../mol-util/param-definition");
 var spine_1 = require("./tree/spine");
 var async_queue_1 = require("../mol-util/async-queue");
-var debug_1 = require("../mol-util/debug");
 var array_1 = require("../mol-util/array");
 var generic_1 = require("../mol-data/generic");
 var object_2 = require("../mol-util/object");
@@ -260,15 +259,19 @@ var State = /** @class */ (function () {
                         return [4 /*yield*/, this.updateTree(snapshot).runInContext(ctx)];
                     case 6:
                         _a.sent();
-                        this.events.log.next(log_entry_1.LogEntry.error('' + e_1));
+                        this.events.log.next(log_entry_1.LogEntry.error('Error during state transaction, reverting'));
                         _a.label = 7;
                     case 7:
                         if (isNested) {
                             this.inTransactionError = true;
                             throw e_1;
                         }
-                        if (options === null || options === void 0 ? void 0 : options.rethrowErrors)
+                        if (options === null || options === void 0 ? void 0 : options.rethrowErrors) {
                             throw e_1;
+                        }
+                        else {
+                            console.error(e_1);
+                        }
                         return [3 /*break*/, 9];
                     case 8:
                         if (!isNested) {
@@ -820,8 +823,7 @@ function updateSubtree(ctx, root) {
                     if (!ctx.hadError)
                         ctx.newCurrent = root;
                     doError(ctx, root, e_2, false);
-                    if (!debug_1.isProductionMode)
-                        console.error(e_2);
+                    console.error(e_2);
                     return [2 /*return*/];
                 case 4:
                     children = ctx.tree.children.get(root).values();

package/lib/commonjs/mol-state/tree/immutable.d.ts

@@ -29,11 +29,23 @@ declare namespace StateTree {
         readonly map: OrderedSet<Ref>['map'];
         toArray(): Ref[];
         first(): Ref;
+        asMutable(): MutableChildSet;
+    }
+    export interface MutableChildSet extends ChildSet {
+        add(ref: Ref): MutableChildSet;
+        remove(ref: Ref): MutableChildSet;
+        asImmutable(): ChildSet;
     }
     interface _Map<T> {
         readonly size: number;
         has(ref: Ref): boolean;
         get(ref: Ref): T;
+        asImmutable(): _Map<T>;
+        asMutable(): MutableMap<T>;
+    }
+    export interface MutableMap<T> extends _Map<T> {
+        set(ref: Ref, value: T): MutableMap<T>;
+        delete(ref: Ref): MutableMap<T>;
     }
     export interface Transforms extends _Map<StateTransform> {
     }
@@ -41,6 +53,12 @@ declare namespace StateTree {
     }
     export interface Dependencies extends _Map<ChildSet> {
     }
+    export interface MutableTransforms extends MutableMap<StateTransform> {
+    }
+    export interface MutableChildren extends MutableMap<MutableChildSet> {
+    }
+    export interface MutableDependencies extends MutableMap<MutableChildSet> {
+    }
     /**
      * Create an instance of an immutable tree.
      */

package/lib/commonjs/mol-state/tree/transient.d.ts

@@ -3,15 +3,14 @@
  *
  * @author David Sehnal <david.sehnal@gmail.com>
  */
-import { Map as ImmutableMap, OrderedSet } from 'immutable';
 import { StateTransform } from '../transform';
 import { StateTree } from './immutable';
 export { TransientTree };
 declare class TransientTree implements StateTree {
     private tree;
-    transforms: ImmutableMap<string, StateTransform<import("../transformer").StateTransformer<import("../object").StateObject<any, import("../object").StateObject.Type<any>>, import("../object").StateObject<any, import("../object").StateObject.Type<any>>, any>>>;
-    children: ImmutableMap<string, OrderedSet<string>>;
-    dependencies: ImmutableMap<string, OrderedSet<string>>;
+    transforms: StateTree.MutableTransforms;
+    children: StateTree.MutableChildren;
+    dependencies: StateTree.MutableDependencies;
     private changedNodes;
     private changedChildren;
     private changedDependencies;

package/lib/commonjs/mol-task/execution/observable.js

@@ -11,7 +11,6 @@ var task_1 = require("../task");
 var now_1 = require("../../mol-util/now");
 var scheduler_1 = require("../util/scheduler");
 var user_timing_1 = require("../util/user-timing");
-var debug_1 = require("../../mol-util/debug");
 function ExecuteObservable(task, observer, updateRateMs) {
     if (updateRateMs === void 0) { updateRateMs = 250; }
     var info = ProgressInfo(task, observer, updateRateMs);
@@ -106,10 +105,7 @@ function execute(task, ctx) {
                         task.onAbort();
                     }
                     _a.label = 6;
-                case 6:
-                    if (debug_1.isDebugMode)
-                        console.error(e_1);
-                    throw e_1;
+                case 6: throw e_1;
                 case 7: return [2 /*return*/];
             }
         });

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

@@ -1,5 +1,5 @@
 /**
- * Copyright (c) 2020 mol* contributors, licensed under MIT, See LICENSE file for more info.
+ * Copyright (c) 2020-2021 mol* contributors, licensed under MIT, See LICENSE file for more info.
  *
  * @author Alexander Rose <alexander.rose@weirdbyte.de>
  */
@@ -10,7 +10,7 @@ export { Clipping };
 declare type Clipping = {
     readonly layers: ReadonlyArray<Clipping.Layer>;
 };
-declare function Clipping(layers: ReadonlyArray<Clipping.Layer>): Clipping;
+declare function Clipping(layers: Clipping['layers']): Clipping;
 declare namespace Clipping {
     type Layer = {
         readonly loci: StructureElement.Loci;
@@ -44,22 +44,14 @@ declare namespace Clipping {
         function fromNames(names: Names[]): Flag;
         function toNames(groups: Groups): Names[];
     }
-    /** Clip object types */
-    const Type: {
-        none: number;
-        plane: number;
-        sphere: number;
-        cube: number;
-        cylinder: number;
-        infiniteCone: number;
-    };
-    type Variant = 'instance' | 'pixel';
     function areEqual(cA: Clipping, cB: Clipping): boolean;
+    /** Check if layers empty */
     function isEmpty(clipping: Clipping): boolean;
-    function remap(clipping: Clipping, structure: Structure): {
-        layers: Layer[];
-    };
+    /** Remap layers */
+    function remap(clipping: Clipping, structure: Structure): Clipping;
+    /** Merge layers */
     function merge(clipping: Clipping): Clipping;
+    /** Filter layers */
     function filter(clipping: Clipping, filter: Structure): Clipping;
     type ScriptLayer = {
         script: Script;

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

@@ -1,6 +1,6 @@
 "use strict";
 /**
- * Copyright (c) 2020 mol* contributors, licensed under MIT, See LICENSE file for more info.
+ * Copyright (c) 2020-2021 mol* contributors, licensed under MIT, See LICENSE file for more info.
  *
  * @author Alexander Rose <alexander.rose@weirdbyte.de>
  */
@@ -72,18 +72,7 @@ exports.Clipping = Clipping;
         }
         Groups.toNames = toNames;
     })(Groups = Clipping.Groups || (Clipping.Groups = {}));
-    /** Clip object types */
-    Clipping.Type = {
-        none: 0,
-        plane: 1,
-        sphere: 2,
-        cube: 3,
-        cylinder: 4,
-        infiniteCone: 5,
-    };
     function areEqual(cA, cB) {
-        if (cA.layers.length === 0 && cB.layers.length === 0)
-            return true;
         if (cA.layers.length !== cB.layers.length)
             return false;
         for (var i = 0, il = cA.layers.length; i < il; ++i) {
@@ -95,10 +84,12 @@ exports.Clipping = Clipping;
         return true;
     }
     Clipping.areEqual = areEqual;
+    /** Check if layers empty */
     function isEmpty(clipping) {
         return clipping.layers.length === 0;
     }
     Clipping.isEmpty = isEmpty;
+    /** Remap layers */
     function remap(clipping, structure) {
         var layers = [];
         for (var _i = 0, _a = clipping.layers; _i < _a.length; _i++) {
@@ -112,6 +103,7 @@ exports.Clipping = Clipping;
         return { layers: layers };
     }
     Clipping.remap = remap;
+    /** Merge layers */
     function merge(clipping) {
         if (isEmpty(clipping))
             return clipping;
@@ -136,6 +128,7 @@ exports.Clipping = Clipping;
         return { layers: layers };
     }
     Clipping.merge = merge;
+    /** Filter layers */
     function filter(clipping, filter) {
         if (isEmpty(clipping))
             return clipping;

package/lib/commonjs/mol-theme/color/atom-id.d.ts

@@ -8,34 +8,34 @@ import { ParamDefinition as PD } from '../../mol-util/param-definition';
 import { ThemeDataContext } from '../../mol-theme/theme';
 export declare const AtomIdColorThemeParams: {
     palette: PD.Mapped<PD.NamedParams<PD.Normalize<{
-        list: {
-            kind: "interpolate" | "set";
-            colors: import("../../mol-util/color/color").ColorListEntry[];
-        };
-    }>, "colors"> | PD.NamedParams<PD.Normalize<{
         maxCount: number;
         hue: [number, number];
         chroma: [number, number];
         luminance: [number, number];
         clusteringStepCount: number;
         minSampleCount: number;
-    }>, "generate">>;
+    }>, "generate"> | PD.NamedParams<PD.Normalize<{
+        list: {
+            kind: "set" | "interpolate";
+            colors: import("../../mol-util/color/color").ColorListEntry[];
+        };
+    }>, "colors">>;
 };
 export declare type AtomIdColorThemeParams = typeof AtomIdColorThemeParams;
 export declare function getAtomIdColorThemeParams(ctx: ThemeDataContext): {
     palette: PD.Mapped<PD.NamedParams<PD.Normalize<{
-        list: {
-            kind: "interpolate" | "set";
-            colors: import("../../mol-util/color/color").ColorListEntry[];
-        };
-    }>, "colors"> | PD.NamedParams<PD.Normalize<{
         maxCount: number;
         hue: [number, number];
         chroma: [number, number];
         luminance: [number, number];
         clusteringStepCount: number;
         minSampleCount: number;
-    }>, "generate">>;
+    }>, "generate"> | PD.NamedParams<PD.Normalize<{
+        list: {
+            kind: "set" | "interpolate";
+            colors: import("../../mol-util/color/color").ColorListEntry[];
+        };
+    }>, "colors">>;
 };
 export declare function AtomIdColorTheme(ctx: ThemeDataContext, props: PD.Values<AtomIdColorThemeParams>): ColorTheme<AtomIdColorThemeParams>;
 export declare const AtomIdColorThemeProvider: ColorTheme.Provider<AtomIdColorThemeParams, 'atom-id'>;

package/lib/commonjs/mol-theme/color/chain-id.d.ts

@@ -8,35 +8,35 @@ import { ParamDefinition as PD } from '../../mol-util/param-definition';
 import { ThemeDataContext } from '../../mol-theme/theme';
 export declare const ChainIdColorThemeParams: {
     palette: PD.Mapped<PD.NamedParams<PD.Normalize<{
-        list: {
-            kind: "interpolate" | "set";
-            colors: import("../../mol-util/color/color").ColorListEntry[];
-        };
-    }>, "colors"> | PD.NamedParams<PD.Normalize<{
         maxCount: number;
         hue: [number, number];
         chroma: [number, number];
         luminance: [number, number];
         clusteringStepCount: number;
         minSampleCount: number;
-    }>, "generate">>;
+    }>, "generate"> | PD.NamedParams<PD.Normalize<{
+        list: {
+            kind: "set" | "interpolate";
+            colors: import("../../mol-util/color/color").ColorListEntry[];
+        };
+    }>, "colors">>;
     asymId: PD.Select<AsymIdType>;
 };
 export declare type ChainIdColorThemeParams = typeof ChainIdColorThemeParams;
 export declare function getChainIdColorThemeParams(ctx: ThemeDataContext): {
     palette: PD.Mapped<PD.NamedParams<PD.Normalize<{
-        list: {
-            kind: "interpolate" | "set";
-            colors: import("../../mol-util/color/color").ColorListEntry[];
-        };
-    }>, "colors"> | PD.NamedParams<PD.Normalize<{
         maxCount: number;
         hue: [number, number];
         chroma: [number, number];
         luminance: [number, number];
         clusteringStepCount: number;
         minSampleCount: number;
-    }>, "generate">>;
+    }>, "generate"> | PD.NamedParams<PD.Normalize<{
+        list: {
+            kind: "set" | "interpolate";
+            colors: import("../../mol-util/color/color").ColorListEntry[];
+        };
+    }>, "colors">>;
     asymId: PD.Select<AsymIdType>;
 };
 declare type AsymIdType = 'auth' | 'label';

package/lib/commonjs/mol-theme/color/element-index.d.ts

@@ -8,34 +8,34 @@ import { ParamDefinition as PD } from '../../mol-util/param-definition';
 import { ThemeDataContext } from '../../mol-theme/theme';
 export declare const ElementIndexColorThemeParams: {
     palette: PD.Mapped<PD.NamedParams<PD.Normalize<{
-        list: {
-            kind: "interpolate" | "set";
-            colors: import("../../mol-util/color/color").ColorListEntry[];
-        };
-    }>, "colors"> | PD.NamedParams<PD.Normalize<{
         maxCount: number;
         hue: [number, number];
         chroma: [number, number];
         luminance: [number, number];
         clusteringStepCount: number;
         minSampleCount: number;
-    }>, "generate">>;
+    }>, "generate"> | PD.NamedParams<PD.Normalize<{
+        list: {
+            kind: "set" | "interpolate";
+            colors: import("../../mol-util/color/color").ColorListEntry[];
+        };
+    }>, "colors">>;
 };
 export declare type ElementIndexColorThemeParams = typeof ElementIndexColorThemeParams;
 export declare function getElementIndexColorThemeParams(ctx: ThemeDataContext): {
     palette: PD.Mapped<PD.NamedParams<PD.Normalize<{
-        list: {
-            kind: "interpolate" | "set";
-            colors: import("../../mol-util/color/color").ColorListEntry[];
-        };
-    }>, "colors"> | PD.NamedParams<PD.Normalize<{
         maxCount: number;
         hue: [number, number];
         chroma: [number, number];
         luminance: [number, number];
         clusteringStepCount: number;
         minSampleCount: number;
-    }>, "generate">>;
+    }>, "generate"> | PD.NamedParams<PD.Normalize<{
+        list: {
+            kind: "set" | "interpolate";
+            colors: import("../../mol-util/color/color").ColorListEntry[];
+        };
+    }>, "colors">>;
 };
 export declare function ElementIndexColorTheme(ctx: ThemeDataContext, props: PD.Values<ElementIndexColorThemeParams>): ColorTheme<ElementIndexColorThemeParams>;
 export declare const ElementIndexColorThemeProvider: ColorTheme.Provider<ElementIndexColorThemeParams, 'element-index'>;

package/lib/commonjs/mol-theme/color/element-symbol.d.ts

@@ -131,59 +131,59 @@ export declare const ElementSymbolColors: ColorMap<{
 }>;
 export declare type ElementSymbolColors = typeof ElementSymbolColors;
 export declare const ElementSymbolColorThemeParams: {
-    carbonColor: PD.Mapped<PD.NamedParams<PD.Normalize<{
+    carbonColor: PD.Mapped<PD.NamedParams<PD.Normalize<unknown>, "element-symbol"> | PD.NamedParams<PD.Normalize<{
         palette: PD.NamedParams<PD.Normalize<{
-            list: any;
-        }>, "colors"> | PD.NamedParams<PD.Normalize<{
             maxCount: any;
             hue: any;
             chroma: any;
             luminance: any;
             clusteringStepCount: any;
             minSampleCount: any;
-        }>, "generate">;
+        }>, "generate"> | PD.NamedParams<PD.Normalize<{
+            list: any;
+        }>, "colors">;
         asymId: "label" | "auth";
     }>, "chain-id"> | PD.NamedParams<PD.Normalize<{
         palette: PD.NamedParams<PD.Normalize<{
-            list: any;
-        }>, "colors"> | PD.NamedParams<PD.Normalize<{
             maxCount: any;
             hue: any;
             chroma: any;
             luminance: any;
             clusteringStepCount: any;
             minSampleCount: any;
-        }>, "generate">;
-    }>, "operator-name"> | PD.NamedParams<PD.Normalize<unknown>, "element-symbol">>;
+        }>, "generate"> | PD.NamedParams<PD.Normalize<{
+            list: any;
+        }>, "colors">;
+    }>, "operator-name">>;
     saturation: PD.Numeric;
     lightness: PD.Numeric;
 };
 export declare type ElementSymbolColorThemeParams = typeof ElementSymbolColorThemeParams;
 export declare function getElementSymbolColorThemeParams(ctx: ThemeDataContext): {
-    carbonColor: PD.Mapped<PD.NamedParams<PD.Normalize<{
+    carbonColor: PD.Mapped<PD.NamedParams<PD.Normalize<unknown>, "element-symbol"> | PD.NamedParams<PD.Normalize<{
         palette: PD.NamedParams<PD.Normalize<{
-            list: any;
-        }>, "colors"> | PD.NamedParams<PD.Normalize<{
             maxCount: any;
             hue: any;
             chroma: any;
             luminance: any;
             clusteringStepCount: any;
             minSampleCount: any;
-        }>, "generate">;
+        }>, "generate"> | PD.NamedParams<PD.Normalize<{
+            list: any;
+        }>, "colors">;
         asymId: "label" | "auth";
     }>, "chain-id"> | PD.NamedParams<PD.Normalize<{
         palette: PD.NamedParams<PD.Normalize<{
-            list: any;
-        }>, "colors"> | PD.NamedParams<PD.Normalize<{
             maxCount: any;
             hue: any;
             chroma: any;
             luminance: any;
             clusteringStepCount: any;
             minSampleCount: any;
-        }>, "generate">;
-    }>, "operator-name"> | PD.NamedParams<PD.Normalize<unknown>, "element-symbol">>;
+        }>, "generate"> | PD.NamedParams<PD.Normalize<{
+            list: any;
+        }>, "colors">;
+    }>, "operator-name">>;
     saturation: PD.Numeric;
     lightness: PD.Numeric;
 };

package/lib/commonjs/mol-theme/color/entity-id.d.ts

@@ -8,34 +8,34 @@ import { ParamDefinition as PD } from '../../mol-util/param-definition';
 import { ThemeDataContext } from '../../mol-theme/theme';
 export declare const EntityIdColorThemeParams: {
     palette: PD.Mapped<PD.NamedParams<PD.Normalize<{
-        list: {
-            kind: "interpolate" | "set";
-            colors: import("../../mol-util/color/color").ColorListEntry[];
-        };
-    }>, "colors"> | PD.NamedParams<PD.Normalize<{
         maxCount: number;
         hue: [number, number];
         chroma: [number, number];
         luminance: [number, number];
         clusteringStepCount: number;
         minSampleCount: number;
-    }>, "generate">>;
+    }>, "generate"> | PD.NamedParams<PD.Normalize<{
+        list: {
+            kind: "set" | "interpolate";
+            colors: import("../../mol-util/color/color").ColorListEntry[];
+        };
+    }>, "colors">>;
 };
 export declare type EntityIdColorThemeParams = typeof EntityIdColorThemeParams;
 export declare function getEntityIdColorThemeParams(ctx: ThemeDataContext): {
     palette: PD.Mapped<PD.NamedParams<PD.Normalize<{
-        list: {
-            kind: "interpolate" | "set";
-            colors: import("../../mol-util/color/color").ColorListEntry[];
-        };
-    }>, "colors"> | PD.NamedParams<PD.Normalize<{
         maxCount: number;
         hue: [number, number];
         chroma: [number, number];
         luminance: [number, number];
         clusteringStepCount: number;
         minSampleCount: number;
-    }>, "generate">>;
+    }>, "generate"> | PD.NamedParams<PD.Normalize<{
+        list: {
+            kind: "set" | "interpolate";
+            colors: import("../../mol-util/color/color").ColorListEntry[];
+        };
+    }>, "colors">>;
 };
 export declare function EntityIdColorTheme(ctx: ThemeDataContext, props: PD.Values<EntityIdColorThemeParams>): ColorTheme<EntityIdColorThemeParams>;
 export declare const EntityIdColorThemeProvider: ColorTheme.Provider<EntityIdColorThemeParams, 'entity-id'>;