Skip to content

GravionLabs/elysion / .agents/skills/angular-developer

angular-developer

Verified

Generates Angular code and provides architectural guidance. Trigger when creating projects, components, services, or HTTP communication, or for best practices on reactivity (signals, linkedSignal, resource, httpResource), forms, dependency injection, routing, SSR, accessibility (ARIA), animations, styling (component styles, Tailwind CSS), testing, naming conventions, or CLI tooling.

FileKindSize
SKILL.mdskill md10.5 KB
references/angular-animations.mdmarkdown3.9 KB
references/angular-aria.mdmarkdown18.2 KB
references/cli.mdmarkdown3.6 KB
references/component-harnesses.mdmarkdown2.7 KB
references/component-styling.mdmarkdown2.5 KB
references/components.mdmarkdown3.8 KB
references/creating-services.mdmarkdown3.2 KB
references/data-resolvers.mdmarkdown1.6 KB
references/define-routes.mdmarkdown2.1 KB
references/defining-providers.mdmarkdown2.2 KB
references/di-fundamentals.mdmarkdown3.4 KB
references/e2e-testing.mdmarkdown884 B
references/effects.mdmarkdown2.7 KB
references/environment-configuration.mdmarkdown3.3 KB
references/hierarchical-injectors.mdmarkdown2.1 KB
references/host-elements.mdmarkdown2.1 KB
references/http-client.mdmarkdown5.4 KB
references/injection-context.mdmarkdown1.9 KB
references/inputs.mdmarkdown2.4 KB
references/linked-signal.mdmarkdown2.6 KB
references/loading-strategies.mdmarkdown1.5 KB
references/mcp.mdmarkdown3.2 KB
references/migrations.mdmarkdown2.0 KB
references/naming-conventions.mdmarkdown5.4 KB
references/navigate-to-routes.mdmarkdown1.6 KB
references/outputs.mdmarkdown2.6 KB
references/pipes.mdmarkdown3.8 KB
references/reactive-forms.mdmarkdown3.5 KB
references/rendering-strategies.mdmarkdown1.8 KB
references/resource.mdmarkdown3.9 KB
references/route-animations.mdmarkdown1.6 KB
references/route-guards.mdmarkdown1.8 KB
references/router-lifecycle.mdmarkdown1.5 KB
references/router-testing.mdmarkdown3.7 KB
references/show-routes-with-outlets.mdmarkdown1.6 KB
references/signal-forms.mdmarkdown27.2 KB
references/signals-overview.mdmarkdown2.8 KB
references/tailwind-css.mdmarkdown1.8 KB
references/template-driven-forms.mdmarkdown3.7 KB
references/testing-fundamentals.mdmarkdown2.5 KB

references/resource.md

View on GitHub
# Async Reactivity with `resource`

A `Resource` incorporates asynchronous data fetching into Angular's signal-based reactivity. It executes an async loader function whenever its dependencies change, exposing the status and result as synchronous signals.

## Basic Usage

The `resource` function accepts an options object with two main properties:

1. `params`: A reactive computation (like `computed`). When signals read here change, the resource re-fetches.
2. `loader`: An async function that fetches data based on the parameters.

```ts
import { Component, resource, signal, computed } from '@angular/core';

@Component({...})
export class UserProfile {
  protected readonly userId = signal('123');

  protected readonly userResource = resource({
    // Reactively tracking userId
    params: () => ({ id: this.userId() }),

    // Executes whenever params change
    loader: async ({ params, abortSignal }) => {
      const response = await fetch(`/api/users/${params.id}`, { signal: abortSignal });
      if (!response.ok) throw new Error('Network error');
      return response.json();
    }
  });

  // Use the resource value in computed signals
  protected readonly userName = computed(() => {
    if (this.userResource.hasValue()) {
      return this.userResource.value()?.name;
    } else if (this.userResource.error()) {
      return 'Failed to load';
    } else {
      return 'Loading...';
    }
  });
}
```

## Aborting Requests

If the `params` signal changes while a previous loader is still running, the `Resource` will attempt to abort the outstanding request using the provided `abortSignal`. **Always pass `abortSignal` to your `fetch` calls.**

## Reloading Data

You can imperatively force the resource to re-run the loader without the params changing by calling `.reload()`.

```ts
this.userResource.reload();
```

## Resource Status Signals

The `Resource` object provides several signals to read its current state:

- `value()`: The resolved data, or `undefined` if there is none yet. **Throws if the resource is in the `'error'` status**, so guard reads with `hasValue()` or check `error()` first.
- `hasValue()`: Type-guard boolean. `true` if a value exists. It is `false` (and does not throw) in the `'error'` status.
- `isLoading()`: Boolean indicating if the loader is currently running (`'loading'` or `'reloading'`).
- `error()`: The error thrown by the loader, or `undefined`.
- `status()`: A string constant representing the exact state (`'idle'`, `'loading'`, `'resolved'`, `'error'`, `'reloading'`, `'local'`).

| `status()`    | `value()`                    | Meaning                                                   |
| ------------- | ---------------------------- | --------------------------------------------------------- |
| `'idle'`      | `undefined`                  | `params` returned `undefined`, so the loader did not run. |
| `'loading'`   | `undefined`                  | The loader is running because `params` changed.           |
| `'reloading'` | the previous value           | The loader is running because of `.reload()`.             |
| `'resolved'`  | the loaded value             | The loader completed.                                     |
| `'error'`     | **throws**                   | The loader threw or rejected.                             |
| `'local'`     | the value passed to `.set()` | The value was set locally.                                |

Do not read `value()` directly in a template or computed signal without a guard, because a failed request would throw there.

## Local Mutation

You can optimistically update the resource's value directly. This changes the status to `'local'`.

```ts
this.userResource.value.set({name: 'Optimistic Update'});
```

## Reactive Data Fetching with `httpResource`

If you are using Angular's `HttpClient`, prefer using `httpResource`. It is a specialized wrapper that leverages the Angular HTTP stack (including interceptors) while providing the same signal-based resource API.
finishing-a-development-branchobra/superpowersUse when implementation is complete, all tests pass, and you need to decide how to integrate the workStars: 321kUpdated Claude CodeCodexVerifiedInstall
systematic-debuggingobra/superpowersUse when encountering any bug, test failure, or unexpected behavior, before proposing fixesStars: 321kUpdated Claude CodeCodexVerifiedInstall
test-driven-developmentobra/superpowersUse when implementing any feature or bugfix, before writing implementation codeStars: 321kUpdated Claude CodeCodexVerifiedInstall
skill-creatoranthropics/skillsCreate new skills, modify and improve existing skills, and measure skill performance. Use when users want to create a skill from scratch, edit, or optimize an existing skill, run evals to test a skill, benchmark skill performance with variance analysis, or optimize a skill's description for better triggering accuracy.Stars: 197kUpdated Claude CodeCodexVerifiedInstall