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/commonjs/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/commonjs/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/commonjs/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/commonjs/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/commonjs/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>;

package/lib/commonjs/mol-theme/color/unit-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 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 CHANGED Viewed

@@ -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<{
                 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;
         }, "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-util/color/palette.d.ts CHANGED Viewed

@@ -15,33 +15,33 @@ declare const DefaultGetPaletteProps: {
 declare type GetPaletteProps = typeof DefaultGetPaletteProps;
 export declare function getPaletteParams(props?: Partial<GetPaletteProps>): {
     palette: PD.Mapped<PD.NamedParams<PD.Normalize<{
-        list: {
-            kind: "interpolate" | "set";
-            colors: import("./color").ColorListEntry[];
-        };
-    }>, "colors"> | PD.NamedParams<PD.Normalize<{
         maxCount: number;
         hue: [number, number];
         chroma: [number, number];
         luminance: [number, number];
         clusteringStepCount: number;
         minSampleCount: number;
-    }>, "generate">>;
-};
-declare const DefaultPaletteProps: PD.Values<{
-    palette: PD.Mapped<PD.NamedParams<PD.Normalize<{
+    }>, "generate"> | PD.NamedParams<PD.Normalize<{
         list: {
-            kind: "interpolate" | "set";
+            kind: "set" | "interpolate";
             colors: import("./color").ColorListEntry[];
         };
-    }>, "colors"> | PD.NamedParams<PD.Normalize<{
+    }>, "colors">>;
+};
+declare const DefaultPaletteProps: PD.Values<{
+    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("./color").ColorListEntry[];
+        };
+    }>, "colors">>;
 }>;
 declare type PaletteProps = typeof DefaultPaletteProps;
 declare const DefaultLabelOptions: {

package/lib/commonjs/servers/model/config.js CHANGED Viewed

@@ -201,7 +201,6 @@ function addJsonConfigArgs(parser) {
             'If a property is not specified, cmd line param/OS variable/default value are used.'
         ].join('\n'),
         required: false,
-        action: 'store_true'
     });
     parser.add_argument('--printCfg', { help: 'Print current config for validation and exit.', required: false, action: 'store_true' });
     parser.add_argument('--cfgTemplate', { help: 'Prints default JSON config template to be modified and exits.', required: false, action: 'store_true' });