Przejdź do treści
Biblioteka skilli
Programowanie · Budowanie i kod

gpui-entity

/gpui-entity

Obsługuje zarządzanie encjami i stanem w GPUI: stan komponentów, koordynacja między komponentami, aktualizacje stanu z operacji asynchronicznych i wzorce reaktywne.

Repozytorium
zqlz ↗
Licencja
GPL-3.0
Ostatnia zmiana repozytorium
17.10.2026

Ocena i bezpieczeństwo

100/ 100Klasa: dobry
Format25 / 25
Frontmatter z nazwą i opisem, poprawna nazwa, opis do 1024 znaków, nazwa zgodna z folderem.
Odkrywalność25 / 25
Opis mówi, kiedy użyć skilla, ma sensowną długość i jest w 3. osobie.
Treść35 / 35
Co najmniej 150 słów i do 500 linii, nagłówki, listy kroków, przykłady albo kod.
Higiena15 / 15
Bez zaślepek typu TODO, bez ścieżek Windows, z licencją.
Ryzykobrak sygnałów w skanie
Pliki w paczce
5
Skrypty
0
Komentarze HTML
0
Adresy URL w SKILL.md
0
Przestarzałość

Brak sygnałów. Repozytorium zmienione 17.10.2026, bez odwołań do wycofanych modeli i API.

Licencja

GPL-3.0, otwarta.

Co robi i kiedy

Obsługuje zarządzanie encjami i stanem w GPUI: stan komponentów, koordynacja między komponentami, aktualizacje stanu z operacji asynchronicznych i wzorce reaktywne.

Oryginalny opis (EN)

Entity management and state handling in GPUI. Use when working with entities, managing component state, coordinating between components, handling async operations with state updates, or implementing reactive patterns. Entities provide safe concurrent access to application state.

Jak działa

  1. Overview
  2. Quick Start
  3. Core Principles
  4. Common Use Cases
  5. Reference Documentation
Sekcje z nagłówków SKILL.md, w oryginale · 165 linii, 529 słów
Podgląd SKILL.md
---
name: gpui-entity
description: Entity management and state handling in GPUI. Use when working with entities, managing component state, coordinating between components, handling async operations with state updates, or implementing reactive patterns. Entities provide safe concurrent access to application state.
---

## Overview

An `Entity<T>` is a handle to state of type `T`, providing safe access and updates.

**Key Methods:**
- `entity.read(cx)` → `&T` - Read-only access
- `entity.read_with(cx, |state, cx| ...)` → `R` - Read with closure
- `entity.update(cx, |state, cx| ...)` → `R` - Mutable update
- `entity.downgrade()` → `WeakEntity<T>` - Create weak reference
- `entity.entity_id()` → `EntityId` - Unique identifier

**Entity Types:**
- **`Entity<T>`**: Strong reference (increases ref count)
- **`WeakEntity<T>`**: Weak reference (doesn't prevent cleanup, returns `Result`)

## Quick Start

### Creating and Using Entities

```rust
// Create entity
let counter = cx.new(|cx| Counter { count: 0 });

// Read state
let count = counter.read(cx).count;

// Update state
counter.update(cx, |state, cx| {
    state.count += 1;
    cx.notify(); // Trigger re-render
});

// Weak reference (for closures/callbacks)
let weak = counter.downgrade();
let _ = weak.update(cx, |state, cx| {
    state.count += 1;
    cx.notify();
});
```

### In Components

```rust
struct MyComponent {
    shared_state: Entity<SharedData>,
}

impl MyComponent {
    fn new(cx: &mut App) -> Entity<Self> {
        let shared = cx.new(|_| SharedData::default());

        cx.new(|cx| Self {
            shared_state: shared,
        })
    }

    fn update_shared(&mut self, cx: &mut Context<Self>) {
        self.shared_state.update(cx, |state, cx| {
            state.value = 42;
            cx.notify();
        });
    }
}
```

### Async Operations

```rust
impl MyComponent {
    fn fetch_data(&mut self, cx: &mut Context<Self>) {
        let weak_self = cx.entity().downgrade();

        cx.spawn(async move |cx| {
            let data = fetch_from_api().await;

            // Update entity safely
            let _ = weak_self.update(cx, |state, cx| {
                state.data = Some(data);
                cx.notify();
            });
        }).detach();
    }
}
```

## Core Principles

### Always Use Weak References in Closures

```rust
// ✅ Good: Weak reference prevents retain cycles
let weak = cx.entity().downgrade();
callback(move || {
    let _ = weak.update(cx, |state, cx| cx.notify());
});

// ❌ Bad: Strong reference may cause memory leak
let strong = cx.entity();
callback(move || {
    strong.update(cx, |state, cx| cx.notify());
});
```

### Use Inner Context

```rust
// ✅ Good: Use inner cx from closure
entity.update(cx, |state, inner_cx| {
    inner_cx.notify(); // Correct
});

// ❌ Bad: Use outer cx (multiple borrow error)
entity.update(cx, |state, inner_cx| {
    cx.notify(); // Wrong!
});
```

### Avoid Nested Updates

```rust
// ✅ Good: Sequential updates
entity1.update(cx, |state, cx| { /* ... */ });
entity2.update(cx, |state, cx| { /* ... */ });

// ❌ Bad: Nested updates (may panic)
entity1.update(cx, |_, cx| {
    entity2.update(cx, |_, cx| { /* ... */ });
});
```

## Common Use Cases

1. **Component State**: Internal state that needs reactivity
2. **Shared State**: State shared between multiple components
3. **Parent-Child**: Coordinating between related components (use weak refs)
4. **Async State**: Managing state that changes from async operations
5. **Observations**: Reacting to changes in other entities

## Reference Documentation

### Complete API Documentation
- **Entity API**: See [api-reference.md](references/api-reference.md)
  - Entity types, methods, lifecycle
  - Context methods, async operations
  - Error handling, type conversions

### Implementation Guides
- **Patterns**: See [patterns.md](references/patterns.md)
  - Model-view separation, state management
  - Cross-entity communication, async operations
  - Observer pattern, event subscription
  - Pattern selection guide

- **Best Practices**: See [best-practices.md](references/best-practices.md)
  - Avoiding common pitfalls, memory leaks
  - Performance optimization, batching updates
  - Lifecycle management, cleanup
  - Async best practices, testing

- **Advanced Patterns**: See [advanced.md](references/advanced.md)
  - Entity collections, registry pattern
  - Debounced/throttled updates, state machines
  - Entity snapshots, transactions, pools
Pliki w paczce (5)
  • SKILL.md 4 KB
  • references/advanced.md 12 KB
  • references/api-reference.md 8 KB
  • references/best-practices.md 12 KB
  • references/patterns.md 13 KB

Wersje

W bazie nie ma innych skilli o nazwie gpui-entity.

Migawka bazy z 13.11.2026 · wersja paczki 694430a22931 (skrót SHA-256 całej paczki)

Pobrania w ostatnich 30 dniach: 1 · ranking

Zgłoś problem z tym skillem: szkodliwa treść, błędny opis albo prośba autora o usunięcie.

Podobne skille

  • 100gpui-entities
    Pokazuje wzorce Entity i kontekstu do zarządzania stanem w GPUI: stan komponentów, cykl życia encji, subskrypcje i typowe pułapki dostępu do encji.
  • 100gpui-context
    Obsługuje zarządzanie kontekstami w GPUI (App, Window, AsyncApp), aktualizacje encji i operacje na oknach, gdzie każdy typ kontekstu daje inne możliwości.
  • 100gpui-async
    Obsługuje operacje asynchroniczne i zadania w tle w GPUI: spawn, asynchroniczne I/O, długie obliczenia i koordynacja aktualizacji interfejsu z pracą w tle.
  • 100gpui-async
    Pokazuje wzorce asynchroniczności i współbieżności w aplikacjach GPUI: zadania w tle, async/await, zarządzanie zadaniami i operacje współbieżne.
  • 100gpui-kit
    Pokazuje, jak budować aplikacje desktopowe w Rust z biblioteką GPUI Kit: komponenty, stan, motywy, akcje i zadania asynchroniczne.
  • 100gpui-kit-desktop
    Pomaga budować i zmieniać interfejs VoxLocal w GPUI Kit 0.9: widoki, ustawienia, zadania, motywy, powiadomienia i testy UI.

Uwagi i zgłoszenia

Wiadomość trafi do Bartosza Sokolińskiego. Adres e-mail jest potrzebny tylko do odpowiedzi. Szczegóły w polityce prywatności.