molstar 2.3.3 → 2.3.8

package/lib/commonjs/mol-theme/color/operator-name.d.ts

@@ -8,34 +8,34 @@ import { ParamDefinition as PD } from '../../mol-util/param-definition';
 import { ThemeDataContext } from '../theme';
 export declare const OperatorNameColorThemeParams: {
     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 OperatorNameColorThemeParams = typeof OperatorNameColorThemeParams;
 export declare function getOperatorNameColorThemeParams(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 OperatorNameColorTheme(ctx: ThemeDataContext, props: PD.Values<OperatorNameColorThemeParams>): ColorTheme<OperatorNameColorThemeParams>;
 export declare const OperatorNameColorThemeProvider: ColorTheme.Provider<OperatorNameColorThemeParams, 'operator-name'>;

package/lib/commonjs/mol-theme/color/polymer-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 PolymerIdColorThemeParams: {
     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 PolymerIdColorThemeParams = typeof PolymerIdColorThemeParams;
 export declare function getPolymerIdColorThemeParams(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 PolymerIdColorTheme(ctx: ThemeDataContext, props: PD.Values<PolymerIdColorThemeParams>): ColorTheme<PolymerIdColorThemeParams>;
 export declare const PolymerIdColorThemeProvider: ColorTheme.Provider<PolymerIdColorThemeParams, 'polymer-id'>;

package/lib/commonjs/mol-theme/color/polymer-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 PolymerIndexColorThemeParams: {
     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 PolymerIndexColorThemeParams = typeof PolymerIndexColorThemeParams;
 export declare function getPolymerIndexColorThemeParams(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 type PolymerIndexColorThemeProps = PD.Values<typeof PolymerIndexColorThemeParams>;
 export declare function PolymerIndexColorTheme(ctx: ThemeDataContext, props: PD.Values<PolymerIndexColorThemeParams>): ColorTheme<PolymerIndexColorThemeParams>;

package/lib/commonjs/mol-theme/color/unit-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 UnitIndexColorThemeParams: {
     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 UnitIndexColorThemeParams = typeof UnitIndexColorThemeParams;
 export declare function getUnitIndexColorThemeParams(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 UnitIndexColorTheme(ctx: ThemeDataContext, props: PD.Values<UnitIndexColorThemeParams>): ColorTheme<UnitIndexColorThemeParams>;
 export declare const UnitIndexColorThemeProvider: ColorTheme.Provider<UnitIndexColorThemeParams, 'unit-index'>;

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

@@ -56,108 +56,108 @@ declare namespace ColorTheme {
     export const BuiltIn: {
         'atom-id': Provider<{
             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">>;
         }, "atom-id">;
         'carbohydrate-symbol': Provider<{}, "carbohydrate-symbol">;
         'chain-id': Provider<{
             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<"label" | "auth">;
         }, "chain-id">;
         'element-index': Provider<{
             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">>;
         }, "element-index">;
         'element-symbol': Provider<{
-            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;
         }, "element-symbol">;
         'entity-id': Provider<{
             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">>;
-        }, "entity-id">;
-        'entity-source': Provider<{
-            palette: PD.Mapped<PD.NamedParams<PD.Normalize<{
+            }>, "generate"> | PD.NamedParams<PD.Normalize<{
                 list: {
-                    kind: "interpolate" | "set";
+                    kind: "set" | "interpolate";
                     colors: import("../mol-util/color/color").ColorListEntry[];
                 };
-            }>, "colors"> | PD.NamedParams<PD.Normalize<{
+            }>, "colors">>;
+        }, "entity-id">;
+        'entity-source': Provider<{
+            palette: PD.Mapped<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">>;
         }, "entity-source">;
         hydrophobicity: Provider<{
             list: PD.ColorList;
@@ -165,34 +165,34 @@ declare namespace ColorTheme {
         }, "hydrophobicity">;
         illustrative: Provider<{
             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<"label" | "auth">;
         }, "illustrative">;
         'model-index': Provider<{
             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">>;
         }, "model-index">;
         'molecule-type': Provider<{
             saturation: PD.Numeric;
@@ -204,33 +204,33 @@ declare namespace ColorTheme {
         }, "occupancy">;
         'operator-hkl': Provider<{
             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">>;
-        }, "operator-hkl">;
-        'operator-name': Provider<{
-            palette: PD.Mapped<PD.NamedParams<PD.Normalize<{
+            }>, "generate"> | PD.NamedParams<PD.Normalize<{
                 list: {
-                    kind: "interpolate" | "set";
+                    kind: "set" | "interpolate";
                     colors: import("../mol-util/color/color").ColorListEntry[];
                 };
-            }>, "colors"> | PD.NamedParams<PD.Normalize<{
+            }>, "colors">>;
+        }, "operator-hkl">;
+        'operator-name': Provider<{
+            palette: PD.Mapped<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">>;
         }, "operator-name">;
         'partial-charge': Provider<{
             domain: PD.Interval;
@@ -238,33 +238,33 @@ declare namespace ColorTheme {
         }, "partial-charge">;
         'polymer-id': Provider<{
             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">>;
-        }, "polymer-id">;
-        'polymer-index': Provider<{
-            palette: PD.Mapped<PD.NamedParams<PD.Normalize<{
+            }>, "generate"> | PD.NamedParams<PD.Normalize<{
                 list: {
-                    kind: "interpolate" | "set";
+                    kind: "set" | "interpolate";
                     colors: import("../mol-util/color/color").ColorListEntry[];
                 };
-            }>, "colors"> | PD.NamedParams<PD.Normalize<{
+            }>, "colors">>;
+        }, "polymer-id">;
+        'polymer-index': Provider<{
+            palette: PD.Mapped<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">>;
         }, "polymer-index">;
         'residue-name': Provider<{
             saturation: PD.Numeric;
@@ -284,18 +284,18 @@ declare namespace ColorTheme {
         }, "uncertainty">;
         'unit-index': Provider<{
             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">>;
         }, "unit-index">;
         uniform: Provider<{
             value: PD.Color;

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

@@ -18,6 +18,7 @@ export declare const DefaultLabelOptions: {
 export declare type LabelOptions = typeof DefaultLabelOptions;
 export declare function lociLabel(loci: Loci, options?: Partial<LabelOptions>): string;
 export declare function structureElementStatsLabel(stats: StructureElement.Stats, options?: Partial<LabelOptions>): string;
+export declare function structureElementLociLabelMany(locis: StructureElement.Loci[], options?: Partial<LabelOptions>): string;
 export declare function bondLabel(bond: Bond.Location, options?: Partial<LabelOptions>): string;
 export declare function bundleLabel(bundle: Loci.Bundle<any>, options?: Partial<LabelOptions>): string;
 export declare function _bundleLabel(bundle: Loci.Bundle<any>, options: LabelOptions): string;