mol-state & plugin: transforms and actions must specify param definitions

src/mol-plugin/behavior/behavior.ts

@@ -37,7 +37,7 @@ namespace PluginBehavior {
             group: string,
             description?: string
         },
-        params(a: Root, globalCtx: PluginContext): { [K in keyof P]: ParamDefinition.Any }
+        params?(a: Root, globalCtx: PluginContext): { [K in keyof P]: ParamDefinition.Any }
     }
 
     export function create<P>(params: CreateParams<P>) {

src/mol-plugin/behavior/dynamic/representation.ts

@@ -25,8 +25,7 @@ export const HighlightLoci = PluginBehavior.create({
             });
         }
     },
-    display: { name: 'Highlight Loci on Canvas', group: 'Data' },
-    params: () => ({})
+    display: { name: 'Highlight Loci on Canvas', group: 'Data' }
 });
 
 export const SelectLoci = PluginBehavior.create({
@@ -39,6 +38,5 @@ export const SelectLoci = PluginBehavior.create({
             });
         }
     },
-    display: { name: 'Select Loci on Canvas', group: 'Data' },
-    params: () => ({})
+    display: { name: 'Select Loci on Canvas', group: 'Data' }
 });

src/mol-plugin/state/transforms/data.ts

@@ -56,7 +56,6 @@ const ParseCif = PluginStateTransform.Create<SO.Data.String | SO.Data.Binary, SO
     },
     from: [SO.Data.String, SO.Data.Binary],
     to: [SO.Data.Cif],
-    params: () => ({}),
     apply({ a }) {
         return Task.create('Parse CIF', async ctx => {
             const parsed = await (SO.Data.String.is(a) ? CIF.parse(a.data) : CIF.parseBinary(a.data)).runInContext(ctx);

src/mol-plugin/state/transforms/model.ts

@@ -76,7 +76,6 @@ const CreateStructure = PluginStateTransform.Create<SO.Molecule.Model, SO.Molecu
     },
     from: [SO.Molecule.Model],
     to: [SO.Molecule.Structure],
-    params: () => ({}),
     apply({ a, params }) {
         let s = Structure.ofModel(a.data);
         if (params.transform3d) s = Structure.transform(s, params.transform3d);

src/mol-plugin/ui/state/apply-action.tsx

@@ -56,7 +56,9 @@ class ApplyActionContol extends TransformContolBase<ApplyActionContol.Props, App
         if (version === state.version) return null;
 
         const source = props.state.cells.get(props.nodeRef)!.obj!;
-        const params = PD.getDefaultValues(props.action.definition.params(source, props.plugin));
+        const params = props.action.definition.params
+            ? PD.getDefaultValues(props.action.definition.params(source, props.plugin))
+            : { };
 
         const newState: Partial<ApplyActionContol.ComponentState> = {
             ref: props.nodeRef,

src/mol-plugin/ui/state/common.tsx

@@ -16,10 +16,6 @@ import { Subject } from 'rxjs';
 export { StateTransformParameters, TransformContolBase };
 
 class StateTransformParameters extends PurePluginComponent<StateTransformParameters.Props> {
-    getDefinition() {
-        return this.props.info.createDefinition(this.props.info.source, this.plugin)
-    }
-
     validate(params: any) {
         // TODO
         return void 0;
@@ -43,7 +39,6 @@ class StateTransformParameters extends PurePluginComponent<StateTransformParamet
 namespace StateTransformParameters {
     export interface Props {
         info: {
-            createDefinition: Transformer.ParamsDefinition,
             params: PD.Params,
             initialValues: any,
             source: StateObject,
@@ -61,11 +56,10 @@ namespace StateTransformParameters {
 
     export function infoFromAction(plugin: PluginContext, state: State, action: StateAction, nodeRef: Transform.Ref): Props['info'] {
         const source = state.cells.get(nodeRef)!.obj!;
-        const params = action.definition.params(source, plugin);
+        const params = action.definition.params ? action.definition.params(source, plugin) : { };
         const initialValues = PD.getDefaultValues(params);
         return {
             source,
-            createDefinition: action.definition.params,
             initialValues,
             params,
             isEmpty: Object.keys(params).length === 0
@@ -75,11 +69,10 @@ namespace StateTransformParameters {
     export function infoFromTransform(plugin: PluginContext, state: State, transform: Transform): Props['info'] {
         const cell = state.cells.get(transform.ref)!;
         const source: StateObjectCell | undefined = (cell.sourceRef && state.cells.get(cell.sourceRef)!) || void 0;
-        const createDefinition = transform.transformer.definition.params;
-        const params = createDefinition((source && source.obj) as any, plugin);
+        const create = transform.transformer.definition.params;
+        const params = create ? create((source && source.obj) as any, plugin) : { };
         return {
             source: (source && source.obj) as any,
-            createDefinition,
             initialValues: transform.params,
             params,
             isEmpty: Object.keys(params).length === 0

src/mol-state/action.ts

@@ -46,7 +46,7 @@ namespace StateAction {
          */
         apply(params: ApplyParams<A, P>, globalCtx: unknown): T | Task<T>,
 
-        params(a: A, globalCtx: unknown): { [K in keyof P]: PD.Any },
+        params?(a: A, globalCtx: unknown): { [K in keyof P]: PD.Any },
 
         /** Test if the transform can be applied to a given node */
         isApplicable?(a: A, globalCtx: unknown): boolean
@@ -66,7 +66,7 @@ namespace StateAction {
         return create<Transformer.From<T>, void, Transformer.Params<T>>({
             from: def.from,
             display: def.display,
-            params: def.params as Transformer.ParamsDefinition<Transformer.From<T>, Transformer.Params<T>>,
+            params: def.params as Transformer.Definition<Transformer.From<T>, any, Transformer.Params<T>>['params'],
             apply({ cell, state, params }) {
                 const tree = state.build().to(cell.transform.ref).apply(transformer, params);
                 return state.update(tree);

src/mol-state/transformer.ts

@@ -46,10 +46,8 @@ export namespace Transformer {
 
     export enum UpdateResult { Unchanged, Updated, Recreate }
 
-    export const EmptyParams = () => ({});
-
     /** Specify default control descriptors for the parameters */
-    export type ParamsDefinition<A extends StateObject = StateObject, P = any> = (a: A, globalCtx: unknown) => { [K in keyof P]: PD.Any }
+    // export type ParamsDefinition<A extends StateObject = StateObject, P = any> = (a: A, globalCtx: unknown) => { [K in keyof P]: PD.Any }
 
     export interface Definition<A extends StateObject = StateObject, B extends StateObject = StateObject, P extends {} = {}> {
         readonly name: string,
@@ -70,7 +68,7 @@ export namespace Transformer {
          */
         update?(params: UpdateParams<A, B, P>, globalCtx: unknown): Task<UpdateResult> | UpdateResult,
 
-        params(a: A, globalCtx: unknown): { [K in keyof P]: PD.Any },
+        params?(a: A, globalCtx: unknown): { [K in keyof P]: PD.Any },
 
         /** Test if the transform can be applied to a given node */
         isApplicable?(a: A, globalCtx: unknown): boolean,
@@ -136,7 +134,6 @@ export namespace Transformer {
         name: 'root',
         from: [],
         to: [],
-        params: EmptyParams,
         apply() { throw new Error('should never be applied'); },
         update() { return UpdateResult.Unchanged; }
     })