Merge pull request mendix#9224 from mendix/revert-9210-wtf/action-variables

Revert "[WTF-2181] Action Variables"

Author: ConnorLand

content/en/docs/apidocs-mxsdk/apidocs/frontend/pluggable-widgets/pluggable-widgets-client-apis/_index.md

@@ -56,40 +56,24 @@ export interface ActionValue {
 }
 ```
 
-#### canExecute {#canexecute}
+#### 4.1.1 canExecute
 
 The flag `canExecute` indicates if an action can be run under current conditions. This prevents executing actions that are not allowed by the app's security settings. User roles can be set in the microflows and nanoflows, allowing users to call them. For more information on user roles and security, see the [Module Security Reference Guide](/refguide/module-security/).
 
 You can also employ this flag when using a **Call microflow** action triggering a microflow with a parameter. Such an action cannot be run until a parameter object is available, for example when a parent data view has finished loading. Attempting to `execute` an action that cannot be run will have no effect, and generates a debug-level warning message.
 
 The exception to this behavior is when the `ActionValue` is returned by [`ListActionValue.get()`](/apidocs-mxsdk/apidocs/pluggable-widgets-client-apis-list-values/#listactionvalue). In this case, the flag will be true when not all arguments have been loaded. Calling `execute()` for an action with loading arguments will run the action as soon as all arguments become available. While waiting, `isExecuting` will be set to `true` and subsequent calls to `execute()` are ignored. If any arguments become unavailable after loading, the action will not run and a debug-level warning message will be logged.
 
-#### isExecuting {#isexecuting}
+#### 4.1.2 isExecuting
 
 The flag `isExecuting` indicates whether an action is currently running. A long-running action can take seconds to complete. Your component might use this information to render an inline loading indicator which lets users track loading progress. Often it is not desirable to allow a user to trigger multiple actions in parallel. Therefore, a component (maybe based on a configuration) can decide to skip triggering an action while a previous execution is still in progress.
 
 Note that `isExecuting` indicates only whether the current action is running. It does not indicate whether a target nanoflow, microflow, or object operation is running due to another action.
 
-#### execute {#execute}
+#### 4.1.3 execute
 
 The method `execute` triggers the action. It returns nothing and does not guarantee that the action will be started synchronously. But when the action does start, the component will receive a new prop with the `isExecuting` flag set.
 
-When the action property [defines action variables](/apidocs-mxsdk/apidocs/pluggable-widgets-property-types/#action-xml-elements), the `execute()` method expects an object map containing a property for each variable. The variables may be passed as undefined, but need to be set explicitly.
-
-Given an action property that defines two `Decimal` variables `lat` and `long`, and a `String` variable named `label`, its `execute()` method accepts the following input:
-
-```ts
-interface MapWidgetProps {
-    onClick: ActionValue<{ lat: Option<Big>, long: Option<Big>, label: Option<string> }>
-}
-
-onClick.execute({
-    lat: new Big(51.907),
-    long: new Big(4.488),
-    label: undefined
-});
-```
-
 ### DynamicValue {#dynamic-value}
 
 `DynamicValue` is used to represent values that can change over time and is used by many property types. It is defined as follows:

content/en/docs/apidocs-mxsdk/apidocs/frontend/pluggable-widgets/pluggable-widgets-property-types.md

@@ -487,23 +487,6 @@ When a `dataSource` attribute is specified and configured by the user, it is pas
 | `defaultValue` | No       | String         | Default value for the property, the format should be `<ModuleId>.<DocumentId>`                          |
 | `defaultType`  | No       | String         | Default type for the property, supported values are `None`, `OpenPage`, `CallNanoflow`, `CallMicroflow` |
 
-#### XML Elements {#action-xml-elements}
-
-`<actionVariables>` — Defines variables a widget provides when calling [`execute()` on an ActionValue](/apidocs-mxsdk/apidocs/pluggable-widgets-client-apis/#execute). The variables are made available in Studio Pro when configuring [Call a Microflow](/refguide/on-click-event/#call-microflow) and [Call a Nanoflow](/refguide/on-click-event/#call-nanoflow) actions.
-
-`<actionVariable>` (required one or more) — Represents a primitive value provided by the widget as an argument when calling `ActionValue.execute()`. The variable is defined by the following attributes:
-* `key` (required) — The identifier of the variable used in Studio Pro and the Pluggable Widgets API.
-* `type` (required) — The type of the value that the variable represents. Supported types and their corresponding Typescript type are listed in the table below.
-* `caption` (required) — A short description of the variable that is displayed in Studio Pro.
-
-| Action Variable Type | Client Type  |
-| -------------------- | --------- |
-| `String`             | `string`  |
-| `Integer`            | `Big`  |
-| `Decimal`            | `Big`  |
-| `DateTime`           | `Date`    |
-| `Boolean`            | `boolean` |
-
 #### Studio Pro UI
 
 When the property is defined as follows:
@@ -519,22 +502,6 @@ Then the Studio Pro UI for the property appears like this:
 
 {{< figure src="/attachments/apidocs-mxsdk/apidocs/pluggable-widgets/pluggable-widgets-property-types/action.png" class="no-border" >}}
 
-When the action exposes variables with the following XML:
-
-```xml
-<property key="actionWithVariable" type="action">
-	<caption>On click</caption>
-	<description>Action to be performed when button is clicked</description>
-	<actionVariables>
-		<actionVariable key="random" type="Decimal" caption="Random number between 0 and 1" />
-	</actionVariables>
-</property>
-```
-
-The variable appears in the UI like this:
-
-{{< figure src="/attachments/apidocs-mxsdk/apidocs/pluggable-widgets/pluggable-widgets-property-types/action-variable.png" class="no-border" >}}
-
 ### Attribute {#attribute}
 
 The attribute property type allows a widget to work directly with entities' attributes, both reading and writing attributes. Depending on the widget's purposes, a widget should define attribute types it supports.