updates according to V9.0 changes

Author: escamoteur

CLAUDE.md

@@ -64,12 +64,12 @@ flutter run
 
 **CommandSync<TParam, TResult>** (`sync_command.dart`)
 - Wraps synchronous functions
-- **Does NOT support `isExecuting`** - will assert if accessed (sync functions don't give UI time to react)
+- **Does NOT support `isRunning`** - will assert if accessed (sync functions don't give UI time to react)
 - Execution happens immediately on call
 
 **CommandAsync<TParam, TResult>** (`async_command.dart`)
 - Wraps asynchronous functions
-- Full support for `isExecuting` tracking
+- Full support for `isRunning` tracking
 - Updates UI progressively: before execution → during → after completion
 
 **UndoableCommand<TParam, TResult, TUndoState>** (`undoable_command.dart`)
@@ -112,10 +112,10 @@ Every Command exposes multiple `ValueListenable` interfaces for different aspect
    - `data`: The result value
    - `paramData`: Parameter passed to command
    - `error`: Any error that occurred
-   - `isExecuting`: Current execution state
-3. **`.isExecuting`** (`ValueListenable<bool>`): Async only, updated asynchronously
-4. **`.isExecutingSync`** (`ValueListenable<bool>`): Synchronous version for use as restrictions
-5. **`.canExecute`** (`ValueListenable<bool>`): Computed as `!restriction && !isExecuting`
+   - `isRunning`: Current execution state
+3. **`.isRunning`** (`ValueListenable<bool>`): Async only, updated asynchronously
+4. **`.isRunningSync`** (`ValueListenable<bool>`): Synchronous version for use as restrictions
+5. **`.canRun`** (`ValueListenable<bool>`): Computed as `!restriction && !isRunning`
 6. **`.errors`** (`ValueListenable<CommandError<TParam>?>`): Error-specific notifications
 
 ### Error Handling System
@@ -154,28 +154,28 @@ Command.detailedStackTraces = true; // Capture enhanced traces
 Commands can be conditionally disabled via `restriction` parameter:
 
 ```dart
-final restriction = ValueNotifier<bool>(false); // false = can execute
+final restriction = ValueNotifier<bool>(false); // false = can run
 final cmd = Command.createAsync<String, List<Data>>(
   fetchData,
   [],
   restriction: restriction, // Command disabled when true
-  ifRestrictedExecuteInstead: (param) {
+  ifRestrictedRunInstead: (param) {
     // Optional: handle restricted execution (e.g., show login)
   },
 );
 ```
 
 **Important**: `restriction: true` means DISABLED, `false` means enabled.
 
-The `.canExecute` property automatically combines restriction with execution state.
+The `.canRun` property automatically combines restriction with execution state.
 
 ### Widget Integration
 
 **CommandBuilder** (`command_builder.dart`):
 ```dart
 CommandBuilder<String, List<Data>>(
   command: myCommand,
-  whileExecuting: (context, _) => CircularProgressIndicator(),
+  whileRunning: (context, _) => CircularProgressIndicator(),
   onData: (context, data, _) => DataList(data),
   onError: (context, error, param) => ErrorWidget(error),
   onSuccess: (context, _) => SuccessWidget(), // For void result commands
@@ -185,7 +185,7 @@ CommandBuilder<String, List<Data>>(
 **Extension method** for use with get_it_mixin/provider/flutter_hooks:
 ```dart
 result.toWidget(
-  whileExecuting: (lastValue, _) => LoadingWidget(),
+  whileRunning: (lastValue, _) => LoadingWidget(),
   onResult: (data, _) => DataWidget(data),
   onError: (error, lastValue, paramData) => ErrorWidget(error),
 )
@@ -198,19 +198,19 @@ result.toWidget(
 Tests use a `Collector<T>` helper class to accumulate ValueListenable emissions:
 
 ```dart
-final Collector<bool> canExecuteCollector = Collector<bool>();
+final Collector<bool> canRunCollector = Collector<bool>();
 final Collector<CommandResult> cmdResultCollector = Collector<CommandResult>();
 
 void setupCollectors(Command command) {
-  command.canExecute.listen((b, _) => canExecuteCollector(b));
+  command.canRun.listen((b, _) => canRunCollector(b));
   command.results.listen((r, _) => cmdResultCollector(r));
   // ... etc
 }
 
 // In test:
 setupCollectors(command);
 command.run();
-expect(canExecuteCollector.values, [true, false, true]);
+expect(canRunCollector.values, [true, false, true]);
 ```
 
 ### Async Test Utilities
@@ -223,7 +223,7 @@ expect(canExecuteCollector.values, [true, false, true]);
 
 ```bash
 # Run single test by name
-flutter test --name "Execute simple sync action No Param No Result"
+flutter test --name "Run simple sync action No Param No Result"
 
 # Run test group
 flutter test --name "Synchronous Command Testing"
@@ -267,7 +267,7 @@ textChangedCommand.debounce(Duration(milliseconds: 500)).listen((text, _) {
 final saveCmd = Command.createAsync<Data, void>(
   saveData,
   null,
-  restriction: loadCmd.isExecutingSync, // Can't save while loading
+  restriction: loadCmd.isRunningSync, // Can't save while loading
 );
 ```
 
@@ -304,8 +304,8 @@ RefreshIndicator(
    - `.errors` emits `null` at start of each execution to clear previous errors
    - Use `.where((x) => x != null)` from listen_it to filter these out
 
-4. **Sync commands and isExecuting**:
-   - Accessing `.isExecuting` on sync commands throws assertion
+4. **Sync commands and isRunning**:
+   - Accessing `.isRunning` on sync commands throws assertion
    - Use async commands if you need execution state tracking
 
 5. **Global vs Local error handlers**:

COMMAND_PATTERNS_KNOWLEDGE_BASE.md

@@ -621,7 +621,7 @@ errorFilter: ErrorTypeFilter({
     context.l10n.networkError,
     action: ToastAction(
       label: context.l10n.retry,
-      onPressed: () => command.execute(lastParam),
+      onPressed: () => command.run(lastParam),
     ),
   );
 });
@@ -892,7 +892,7 @@ late final loadDataCommand = Command.createAsyncNoParam<Data>(_loadData, null);
 void initState() {
   super.initState();
 
-  loadDataCommand.isExecuting.listen((isLoading, _) {
+  loadDataCommand.isRunning.listen((isLoading, _) {
     setState(() {
       _isLoading = isLoading;
     });
@@ -1022,8 +1022,8 @@ late final createOrderCommand = Command.createAsync<OrderParams, Order>(
     final order = await api.createOrder(params);
 
     // Refresh related data
-    getOrdersCommand.execute();
-    getBalanceCommand.execute();
+    getOrdersCommand.run();
+    getBalanceCommand.run();
 
     // Show success feedback
     toastService.showSuccess(context.l10n.orderCreated);
@@ -1050,15 +1050,15 @@ late final deletePaymentMethodCommand = Command.createAsyncNoResult<String>(
       );
 
       if (nextMethod != null) {
-        await setDefaultPaymentMethodCommand.executeWithFuture(nextMethod.id);
+        await setDefaultPaymentMethodCommand.runAsync(nextMethod.id);
       }
     }
 
     // Now safe to delete
     await api.deletePaymentMethod(paymentMethodId);
 
     // Refresh list
-    getPaymentMethodsCommand.execute();
+    getPaymentMethodsCommand.run();
   },
 );
 ```
@@ -1071,9 +1071,9 @@ late final deletePaymentMethodCommand = Command.createAsyncNoResult<String>(
 late final refreshDashboardCommand = Command.createAsyncNoParamNoResult(
   () async {
     await Future.wait([
-      getOrdersCommand.executeWithFuture(),
-      getNotificationsCommand.executeWithFuture(),
-      getBalanceCommand.executeWithFuture(),
+      getOrdersCommand.runAsync(),
+      getNotificationsCommand.runAsync(),
+      getBalanceCommand.runAsync(),
     ]);
   },
 );
@@ -1089,7 +1089,7 @@ late final loadDataCommand = Command.createAsyncNoParam<Data>(_loadData, null);
 late final saveDataCommand = Command.createAsync<Data, void>(
   _saveData,
   null,
-  restriction: loadDataCommand.isExecutingSync, // Can't save while loading
+  restriction: loadDataCommand.isRunningSync, // Can't save while loading
 );
 ```
 
@@ -1103,10 +1103,10 @@ late final purchaseListingCommand = Command.createAsync<PurchaseParams, Order>(
     final orderDto = await api.storeOrder(params);
 
     // Refresh listing (will show "sold" state)
-    params.listing.loadFullTargetCommand.execute();
+    params.listing.loadFullTargetCommand.run();
 
     // Refresh user's balance
-    userManager.getBalanceCommand.execute();
+    userManager.getBalanceCommand.run();
 
     // Return new order proxy
     return createOrderProxy(orderDto);
@@ -1384,19 +1384,19 @@ errorFilter: const GlobalOnlyErrorFilter(),
 // User sees generic "Something went wrong" toast
 ```
 
-### 8. Use executeWithFuture for Async Coordination
+### 8. Use runAsync for Async Coordination
 
 **Pattern**: When you need to await command completion
 
 ```dart
 // ✅ GOOD: Await command in async function
 Future<void> onRefresh() async {
-  await loadDataCommand.executeWithFuture();
+  await loadDataCommand.runAsync();
 }
 
 // ✅ GOOD: Use with RefreshIndicator
 RefreshIndicator(
-  onRefresh: () => loadDataCommand.executeWithFuture(),
+  onRefresh: () => loadDataCommand.runAsync(),
   child: ListView(...),
 )
 ```
@@ -1425,7 +1425,7 @@ late final loadDataCommand = Command.createAsync(
 );
 ```
 
-### 2. ❌ Using Sync Commands When You Need isExecuting
+### 2. ❌ Using Sync Commands When You Need isRunning
 
 **Problem**: Sync commands don't support execution state tracking
 
@@ -1434,16 +1434,16 @@ late final loadDataCommand = Command.createAsync(
 late final processDataCommand = Command.createSync(_processData, null);
 
 // This will throw assertion error:
-processDataCommand.isExecuting.listen(...); // ❌ ASSERTION FAILS
+processDataCommand.isRunning.listen(...); // ❌ ASSERTION FAILS
 ```
 
 **Solution**: Use async commands for long-running operations
 
 ```dart
-// ✅ GOOD: Async command supports isExecuting
+// ✅ GOOD: Async command supports isRunning
 late final processDataCommand = Command.createAsync(_processData, null);
 
-processDataCommand.isExecuting.listen((isLoading, _) {
+processDataCommand.isRunning.listen((isLoading, _) {
   setState(() => _isLoading = isLoading);
 });
 ```