state-context-interface — правило для Claude Code
Правило state-context-interface для Claude Code: отделяет интерфейс компонентов от источника состояния через контекст с частями state, actions и meta. Один UI подключается к разным провайдерам состояния.
MIT ★ 7 191 обновлён 2026-10-24
.claude/rules/state-context-interface.mdЧто делает state-context-interface
Правило предлагает описывать контекст компонента общим интерфейсом из трёх частей: state, actions и meta. UI-компоненты обращаются к этому контракту, а не к конкретному хуку или хранилищу. Так один и тот же интерфейс можно подключить, например, к локальному состоянию формы или к синхронизированному глобальному состоянию канала.
Провайдер задаёт состояние, действия и метаданные, включая ссылку на поле ввода. Компоненты внутри границы провайдера могут читать состояние и вызывать действия, даже если визуально находятся за пределами Composer.Frame. Это правило для архитектуры React-компонентов; без провайдера, реализующего интерфейс, такой UI не получит нужный контекст.
Какие задачи решает
- отвязать UI-компонент от конкретного хука состояния
- подключить один интерфейс к локальному и глобальному состоянию
- вынести предпросмотр за пределы
Composer.Frame, сохранив доступ к контексту - вызвать отправку из кнопки за пределами компоновщика
Примеры запросов агенту
- Спроектируй контекст компонента с частями
state,actionsиmeta, чтобы UI не зависел от конкретного хука. - Переработай этот компонент так, чтобы локальный и глобальный провайдеры реализовывали один интерфейс.
- Добавь предпросмотр сообщения вне
Composer.Frame, сохранив доступ к состоянию провайдера.
Как установить state-context-interface
Вручную: положить файлы
.claude/rules/state-context-interface.mdПоле paths во frontmatter ограничивает файлы
AGENTS.md
Codex читает AGENTS.md: вставьте текст правила туда
Вручную: положить файлы
.cursor/rules/state-context-interface.mdcВо frontmatter: description, globs, alwaysApply
Вручную: положить файлы
.github/instructions/state-context-interface.instructions.mdПоле applyTo задаёт, к каким файлам применять
Вручную: положить файлы
.devin/rules/state-context-interface.mdВручную: положить файлы
.clinerules/state-context-interface.mdПо шагам, с командами для каждой платформы: AGENTS.md и CLAUDE.md: что это, кто читает и какой выбрать
Вопросы о state-context-interface
Как установить state-context-interface в Claude Code?
Добавьте файл правила по пути .claude/rules/state-context-interface.md. Разместите его в проекте, чтобы Claude Code мог применять правило.
Что делает state-context-interface?
Правило предлагает отделить интерфейс UI-компонентов от реализации состояния с помощью контекста, содержащего state, actions и meta. Разные провайдеры могут реализовать один контракт.
Могут ли компоненты за пределами Composer.Frame читать состояние?
Да. Компоненту достаточно находиться внутри границы провайдера, который предоставляет контекст; визуальная вложенность в Composer.Frame не обязательна.
Исходный текст
state-context-interface.md · MIT
---
title: Define Generic Context Interfaces for Dependency Injection
impact: HIGH
impactDescription: enables dependency-injectable state across use-cases
tags: composition, context, state, typescript, dependency-injection
---
## Define Generic Context Interfaces for Dependency Injection
Define a **generic interface** for your component context with three parts:
`state`, `actions`, and `meta`. This interface is a contract that any provider
can implement—enabling the same UI components to work with completely different
state implementations.
**Core principle:** Lift state, compose internals, make state
dependency-injectable.
**Incorrect (UI coupled to specific state implementation):**
```tsx
function ComposerInput() {
// Tightly coupled to a specific hook
const { input, setInput } = useChannelComposerState()
return <TextInput value={input} onChangeText={setInput} />
}
```
**Correct (generic interface enables dependency injection):**
```tsx
// Define a GENERIC interface that any provider can implement
interface ComposerState {
input: string
attachments: Attachment[]
isSubmitting: boolean
}
interface ComposerActions {
update: (updater: (state: ComposerState) => ComposerState) => void
submit: () => void
}
interface ComposerMeta {
inputRef: React.RefObject<TextInput>
}
interface ComposerContextValue {
state: ComposerState
actions: ComposerActions
meta: ComposerMeta
}
const ComposerContext = createContext<ComposerContextValue | null>(null)
```
**UI components consume the interface, not the implementation:**
```tsx
function ComposerInput() {
const {
state,
actions: { update },
meta,
} = use(ComposerContext)
// This component works with ANY provider that implements the interface
return (
<TextInput
ref={meta.inputRef}
value={state.input}
onChangeText={(text) => update((s) => ({ ...s, input: text }))}
/>
)
}
```
**Different providers implement the same interface:**
```tsx
// Provider A: Local state for ephemeral forms
function ForwardMessageProvider({ children }: { children: React.ReactNode }) {
const [state, setState] = useState(initialState)
const inputRef = useRef(null)
const submit = useForwardMessage()
return (
<ComposerContext
value={{
state,
actions: { update: setState, submit },
meta: { inputRef },
}}
>
{children}
</ComposerContext>
)
}
// Provider B: Global synced state for channels
function ChannelProvider({ channelId, children }: Props) {
const { state, update, submit } = useGlobalChannel(channelId)
const inputRef = useRef(null)
return (
<ComposerContext
value={{
state,
actions: { update, submit },
meta: { inputRef },
}}
>
{children}
</ComposerContext>
)
}
```
**The same composed UI works with both:**
```tsx
// Works with ForwardMessageProvider (local state)
<ForwardMessageProvider>
<Composer.Frame>
<Composer.Input />
<Composer.Submit />
</Composer.Frame>
</ForwardMessageProvider>
// Works with ChannelProvider (global synced state)
<ChannelProvider channelId="abc">
<Composer.Frame>
<Composer.Input />
<Composer.Submit />
</Composer.Frame>
</ChannelProvider>
```
**Custom UI outside the component can access state and actions:**
The provider boundary is what matters—not the visual nesting. Components that
need shared state don't have to be inside the `Composer.Frame`. They just need
to be within the provider.
```tsx
function ForwardMessageDialog() {
return (
<ForwardMessageProvider>
<Dialog>
{/* The composer UI */}
<Composer.Frame>
<Composer.Input placeholder="Add a message, if you'd like." />
<Composer.Footer>
<Composer.Formatting />
<Composer.Emojis />
</Composer.Footer>
</Composer.Frame>
{/* Custom UI OUTSIDE the composer, but INSIDE the provider */}
<MessagePreview />
{/* Actions at the bottom of the dialog */}
<DialogActions>
<CancelButton />
<ForwardButton />
</DialogActions>
</Dialog>
</ForwardMessageProvider>
)
}
// This button lives OUTSIDE Composer.Frame but can still submit based on its context!
function ForwardButton() {
const {
actions: { submit },
} = use(ComposerContext)
return <Button onPress={submit}>Forward</Button>
}
// This preview lives OUTSIDE Composer.Frame but can read composer's state!
function MessagePreview() {
const { state } = use(ComposerContext)
return <Preview message={state.input} attachments={state.attachments} />
}
```
The `ForwardButton` and `MessagePreview` are not visually inside the composer
box, but they can still access its state and actions. This is the power of
lifting state into providers.
The UI is reusable bits you compose together. The state is dependency-injected
by the provider. Swap the provider, keep the UI.
© tech-leads-club · MIT · tech-leads-club/agent-skills