--- title: Programmatic Control description: Controlling the state machines programmatically --- In some cases, you may want to control the state or context values of a machine programmatically via its `props` or based on certain conditions. This is typically known as "controlling" the components. Zag provides a number of ways to control the state of a machine programmatically. ## Setting initial context All machines support setting the controlled and uncontrolled values for context properties. For example: - `defaultOpen` and `open` for controlling the open state of disclosure components - `defaultValue` and `value` for controlling the value of input machines For example, if you want an accordion to start with a specific selected value. Here's how to achieve that: ```tsx const service = useMachine(accordion.machine, { defaultValue: ["item-1"], }) ``` ## Controlled Usage You can pass the context value to the `useMachine` hook directly and provide the `onValueChange` callback to react to the changes. ```jsx const service = useMachine(accordion.machine, { value: props.value, onValueChange(details) { console.log(details) }, }) ``` ## Reactive Context Different frameworks handle reactivity differently when working with Zag machines. Here's how to ensure your machine context stays reactive to prop changes. ### React React props are natively reactive with Zag machines. Simply pass them directly to `useMachine` ```tsx function Checkbox(props) { const service = useMachine(checkbox.machine, { checked: props.checked, onCheckedChange: props.onCheckedChange, }) const api = checkbox.connect(service, normalizeProps) return } ``` ### Vue Use a computed ref or a function that returns the context to make it reactive ```html ``` ### Solid Use a function that returns the context to make it reactive ```tsx function Checkbox(props) { const service = useMachine(checkbox.machine, () => ({ checked: props.checked, onCheckedChange: props.onCheckedChange, })) const api = createMemo(() => checkbox.connect(service, normalizeProps)) return } ``` ### Svelte To make props reactive in Svelte, pass a function that returns the context ```svelte ``` **Why this works:** 1. **Reactive Context**: The function re-evaluates whenever dependencies change, ensuring the machine always has current prop values 2. **State Preservation**: The machine's internal state remains intact while context gets updated 3. **Framework Integration**: This pattern aligns with the framework's reactivity model This approach ensures single-directional data flow while maintaining reactivity. ## Using API methods The `connect` method of the machines provide helpful methods (APIs) to change the machine state or update its context. > This approach is the recommended approach to programmatically update a > machine. Let's say we'd like to change the expanded accordion item in an accordion group. Here's how to do that: ```jsx function Accordion() { // 1. Bind the machine in your framework const service = useMachine(accordion.machine) // 2. Call the connect function const api = accordion.connect(service) // 3. Use exposed methods api.setValue("item-1") return (...) } ```