npm - molstar - Versions diffs - 2.3.3 → 2.3.5 - Mend

molstar 2.3.3 → 2.3.5

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (355) hide show

package/lib/mol-repr/volume/slice.d.ts CHANGED Viewed

@@ -35,7 +35,7 @@ export declare const SliceParams: {
             legend?: import("../../mol-util/legend").Legend | undefined;
         }) | undefined;
     };
-    dimension: PD.Mapped<PD.NamedParams<number, "x"> | PD.NamedParams<number, "y"> | PD.NamedParams<number, "z">>;
+    dimension: PD.Mapped<PD.NamedParams<number, "y"> | PD.NamedParams<number, "x"> | PD.NamedParams<number, "z">>;
     isoValue: PD.Conditioned<Readonly<{
         kind: "absolute";
         absoluteValue: number;
@@ -58,7 +58,7 @@ export declare const SliceParams: {
             relativeValue: number;
         }>, number>;
     }>;
-    interpolation: PD.Select<"nearest" | "catmulrom" | "mitchell" | "bspline">;
+    interpolation: PD.Select<"bspline" | "nearest" | "catmulrom" | "mitchell">;
     alpha: PD.Numeric;
 };
 export declare type SliceParams = typeof SliceParams;
@@ -86,7 +86,7 @@ export declare function getSliceParams(ctx: ThemeRegistryContext, volume: Volume
             legend?: import("../../mol-util/legend").Legend | undefined;
         }) | undefined;
     };
-    dimension: PD.Mapped<PD.NamedParams<number, "x"> | PD.NamedParams<number, "y"> | PD.NamedParams<number, "z">>;
+    dimension: PD.Mapped<PD.NamedParams<number, "y"> | PD.NamedParams<number, "x"> | PD.NamedParams<number, "z">>;
     isoValue: PD.Conditioned<Readonly<{
         kind: "absolute";
         absoluteValue: number;
@@ -109,7 +109,7 @@ export declare function getSliceParams(ctx: ThemeRegistryContext, volume: Volume
             relativeValue: number;
         }>, number>;
     }>;
-    interpolation: PD.Select<"nearest" | "catmulrom" | "mitchell" | "bspline">;
+    interpolation: PD.Select<"bspline" | "nearest" | "catmulrom" | "mitchell">;
     alpha: PD.Numeric;
 };
 export declare function SliceVisual(materialId: number): VolumeVisual<SliceParams>;
@@ -138,7 +138,7 @@ export declare const SliceRepresentationProvider: VolumeRepresentationProvider<{
             legend?: import("../../mol-util/legend").Legend | undefined;
         }) | undefined;
     };
-    dimension: PD.Mapped<PD.NamedParams<number, "x"> | PD.NamedParams<number, "y"> | PD.NamedParams<number, "z">>;
+    dimension: PD.Mapped<PD.NamedParams<number, "y"> | PD.NamedParams<number, "x"> | PD.NamedParams<number, "z">>;
     isoValue: PD.Conditioned<Readonly<{
         kind: "absolute";
         absoluteValue: number;
@@ -161,6 +161,6 @@ export declare const SliceRepresentationProvider: VolumeRepresentationProvider<{
             relativeValue: number;
         }>, number>;
     }>;
-    interpolation: PD.Select<"nearest" | "catmulrom" | "mitchell" | "bspline">;
+    interpolation: PD.Select<"bspline" | "nearest" | "catmulrom" | "mitchell">;
     alpha: PD.Numeric;
 }, "slice">;

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

@@ -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/mol-theme/color/chain-id.d.ts CHANGED Viewed

@@ -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/mol-theme/color/element-index.d.ts CHANGED Viewed

@@ -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/mol-theme/color/element-symbol.d.ts CHANGED Viewed

@@ -133,27 +133,27 @@ export declare type ElementSymbolColors = typeof ElementSymbolColors;
 export declare const ElementSymbolColorThemeParams: {
     carbonColor: PD.Mapped<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">;
+        }>, "generate"> | PD.NamedParams<PD.Normalize<{
+            list: any;
+        }>, "colors">;
     }>, "operator-name"> | PD.NamedParams<PD.Normalize<unknown>, "element-symbol">>;
     saturation: PD.Numeric;
     lightness: PD.Numeric;
@@ -162,27 +162,27 @@ export declare type ElementSymbolColorThemeParams = typeof ElementSymbolColorThe
 export declare function getElementSymbolColorThemeParams(ctx: ThemeDataContext): {
     carbonColor: PD.Mapped<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">;
+        }>, "generate"> | PD.NamedParams<PD.Normalize<{
+            list: any;
+        }>, "colors">;
     }>, "operator-name"> | PD.NamedParams<PD.Normalize<unknown>, "element-symbol">>;
     saturation: PD.Numeric;
     lightness: PD.Numeric;

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

@@ -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'>;

package/lib/mol-theme/color/entity-source.d.ts CHANGED Viewed

@@ -8,34 +8,34 @@ import { ParamDefinition as PD } from '../../mol-util/param-definition';
 import { ThemeDataContext } from '../../mol-theme/theme';
 export declare const EntitySourceColorThemeParams: {
     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 EntitySourceColorThemeParams = typeof EntitySourceColorThemeParams;
 export declare function getEntitySourceColorThemeParams(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 EntitySourceColorTheme(ctx: ThemeDataContext, props: PD.Values<EntitySourceColorThemeParams>): ColorTheme<EntitySourceColorThemeParams>;
 export declare const EntitySourceColorThemeProvider: ColorTheme.Provider<EntitySourceColorThemeParams, 'entity-source'>;

package/lib/mol-theme/color/illustrative.d.ts CHANGED Viewed

@@ -8,35 +8,35 @@ import { ParamDefinition as PD } from '../../mol-util/param-definition';
 import { ThemeDataContext } from '../theme';
 export declare const IllustrativeColorThemeParams: {
     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">;
 };
 export declare type IllustrativeColorThemeParams = typeof IllustrativeColorThemeParams;
 export declare function getIllustrativeColorThemeParams(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<"label" | "auth">;
 };
 export declare function IllustrativeColorTheme(ctx: ThemeDataContext, props: PD.Values<IllustrativeColorThemeParams>): ColorTheme<IllustrativeColorThemeParams>;

package/lib/mol-theme/color/model-index.d.ts CHANGED Viewed

@@ -8,34 +8,34 @@ import { ParamDefinition as PD } from '../../mol-util/param-definition';
 import { ThemeDataContext } from '../../mol-theme/theme';
 export declare const ModelIndexColorThemeParams: {
     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 ModelIndexColorThemeParams = typeof ModelIndexColorThemeParams;
 export declare function getModelIndexColorThemeParams(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 ModelIndexColorTheme(ctx: ThemeDataContext, props: PD.Values<ModelIndexColorThemeParams>): ColorTheme<ModelIndexColorThemeParams>;
 export declare const ModelIndexColorThemeProvider: ColorTheme.Provider<ModelIndexColorThemeParams, 'model-index'>;

package/lib/mol-theme/color/operator-hkl.d.ts CHANGED Viewed

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

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

@@ -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/mol-theme/color/polymer-id.d.ts CHANGED Viewed

@@ -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/mol-theme/color/polymer-index.d.ts CHANGED Viewed

@@ -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>;