嘿，刚好我之前在项目里用XState做中等复杂度UI状态管理时，也遇到过一模一样的场景！结合你的并行状态（SelectionStatus + Operation），给你整理几种实用的实现方案，都是亲测有效的：

这是最直接的方式——当你需要触发动作后留在当前子状态，只需要在转换规则里把target设为.，再搭配守卫判断触发条件就行。

比如在SelectedOne状态下，处理UPDATE_SELECTION事件时，如果只是更新选中项的属性（而非增减选中数量），就用自转换：

const selectionStatusMachine = createMachine({
  id: 'selectionStatus',
  initial: 'selectedNone',
  states: {
    selectedNone: { /* 你的状态逻辑 */ },
    selectedOne: {
      on: {
        UPDATE_SELECTION: [
          {
            target: '.', // 明确指定留在当前SelectedOne状态
            guard: 'isSameItemUpdate', // 守卫：判断只是更新当前选中项
            actions: 'updateSelectedItemDetails' // 执行更新动作
          },
          // 其他分支：比如取消选中跳去selectedNone，新增选中跳去selectedMany
          { target: 'selectedNone', guard: 'isItemDeselected' },
          { target: 'selectedMany', guard: 'isNewItemAdded' }
        ]
      }
    },
    selectedMany: { /* 你的状态逻辑 */ }
  }
});

这种方案的好处是直观，适合不需要改变状态、仅执行动作的场景，守卫可以精准过滤触发自转换的条件。

如果你的子状态有entry/exit动作，自转换会触发这些动作的重新执行（先exit再entry）。要是你不想重复执行这些生命周期逻辑，就用内部转换：

写法很简单，要么省略target，要么显式加internal: true：

selectedOne: {
  entry: ['logSelectedOneEntry'], // 比如进入时打日志
  on: {
    UPDATE_SELECTION: {
      internal: true, // 标记为内部转换，不会触发entry/exit
      guard: 'isSameItemUpdate',
      actions: 'updateSelectedItemDetails'
    }
  }
}

内部转换和自转换的核心区别就是：内部转换完全不会触动状态的生命周期，适合纯动作执行的场景。

如果SelectedOne和SelectedMany都有类似的“更新后留原状态”需求，别重复写代码！把公共的守卫和动作提取出来复用：

// 先定义公共守卫和动作
const sharedGuards = {
  isExistingItemUpdate: (context, event) => {
    // 判断事件里的item是已选中的项，只是更新属性
    return context.selectedItems.some(item => item.id === event.item.id);
  }
};

const sharedActions = {
  updateSelectedItem: (context, event) => {
    context.selectedItems = context.selectedItems.map(item => 
      item.id === event.item.id ? {...item, ...event.updates} : item
    );
  }
};

// 然后在状态机里复用
const selectionStatusMachine = createMachine({
  // ...基础配置
  states: {
    selectedOne: {
      on: {
        UPDATE_SELECTION: [
          { target: '.', guard: sharedGuards.isExistingItemUpdate, actions: sharedActions.updateSelectedItem },
          // 其他转换分支
        ]
      }
    },
    selectedMany: {
      on: {
        UPDATE_SELECTION: [
          { target: '.', guard: sharedGuards.isExistingItemUpdate, actions: sharedActions.updateSelectedItem },
          // 其他转换分支
        ]
      }
    }
  }
}, { guards: sharedGuards, actions: sharedActions });

这样后续修改逻辑只需要改一处，维护起来轻松很多。

因为你是并行状态，有时候可能需要在执行SelectionStatus动作的同时，让Operation状态做一些同步变化（比如从Idle变成Updating，完成后回到Idle）。这时候可以通过发送事件来联动：

// 先定义Operation状态机
const operationMachine = createMachine({
  id: 'operation',
  initial: 'idle',
  states: {
    idle: {
      on: { START_UPDATE: 'updating' }
    },
    updating: {
      // 模拟异步操作完成后回到idle
      after: {
        1500: { target: 'idle', actions: 'notifyUpdateDone' }
      }
    }
  }
});

// 并行状态机
const uiMachine = createMachine({
  type: 'parallel',
  states: {
    selectionStatus: selectionStatusMachine,
    operation: operationMachine
  },
  on: {
    UPDATE_SELECTION: {
      actions: send('START_UPDATE', { to: 'operation' }), // 给Operation发送事件
      // 同时在selectionStatus里处理自转换
    }
  }
});

这样既保证了SelectionStatus留在原状态，又同步了Operation的状态变化，完美适配UI里“加载中”这类场景。

内容的提问来源于stack exchange，提问作者AnimaLupi