@shrkcrft/presets 0.1.0-alpha.2 → 0.1.0-alpha.20

package/dist/builtin/angular21-presets.d.ts

@@ -0,0 +1,9 @@
+import type { IPreset } from '../model/preset.js';
+export declare const ANGULAR_21_SIGNALS: IPreset;
+export declare const ANGULAR_21_ZONELESS: IPreset;
+export declare const ANGULAR_21_CONTROL_FLOW: IPreset;
+export declare const ANGULAR_21_RESOURCE: IPreset;
+export declare const ANGULAR_21_MODERN_DI: IPreset;
+export declare const ANGULAR_21_MODERN: IPreset;
+export declare const ANGULAR_21_PRESETS: readonly IPreset[];
+//# sourceMappingURL=angular21-presets.d.ts.map

package/dist/builtin/angular21-presets.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"angular21-presets.d.ts","sourceRoot":"","sources":["../../src/builtin/angular21-presets.ts"],"names":[],"mappings":"AAaA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,oBAAoB,CAAC;AAmDlD,eAAO,MAAM,kBAAkB,EAAE,OAiC/B,CAAC;AAIH,eAAO,MAAM,mBAAmB,EAAE,OA8BhC,CAAC;AAIH,eAAO,MAAM,uBAAuB,EAAE,OAgCpC,CAAC;AAIH,eAAO,MAAM,mBAAmB,EAAE,OA6BhC,CAAC;AAIH,eAAO,MAAM,oBAAoB,EAAE,OA8BjC,CAAC;AAIH,eAAO,MAAM,iBAAiB,EAAE,OAgD9B,CAAC;AAEH,eAAO,MAAM,kBAAkB,EAAE,SAAS,OAAO,EAO/C,CAAC"}

package/dist/builtin/angular21-presets.js

@@ -0,0 +1,218 @@
+// Modern Angular 18 / 19 / 20 / 21 preset family.
+//
+// Six presets — five focused on a single area of the modernisation surface,
+// one comprehensive that composes the rest. They target Angular workspaces
+// (HasAngular) with `weight` set above `modern-angular` (R26, weight 9) so
+// the recommender prefers them when the workspace shape allows.
+//
+// Each preset's `paths` includes the standard Angular structure
+// (src/app/, src/app/components/, src/app/services/) so the init paths
+// advisory annotator can verify against the live workspace.
+import { WorkspaceProfile } from '@shrkcrft/workspace';
+import { definePreset } from "../define/define-preset.js";
+import { ANGULAR_PATH_APP, ANGULAR_PATH_COMPONENTS, ANGULAR_PATH_SERVICES, COMMON_AGENT_BRIEFING, COMMON_PIPELINE_CONTEXT_ONLY, COMMON_PIPELINE_FEATURE_DEV, COMMON_PIPELINE_UNIT_TEST, COMMON_SAFETY_RULE, OVERVIEW_DOC, } from "./shared-snippets.js";
+import { NG21_AFTER_RENDER, NG21_BOOTSTRAP_APPLICATION, NG21_CONTROL_FLOW, NG21_DEFER, NG21_HTTP_RESOURCE, NG21_HYBRID_RENDERING, NG21_INJECT_FN, NG21_LET_TEMPLATE, NG21_LINKED_SIGNAL, NG21_MODEL_TWO_WAY, NG21_NG_OPTIMIZED_IMAGE, NG21_NO_EFFECT_FOR_DERIVED, NG21_NO_NGMODULES, NG21_NO_ZONE_APIS, NG21_PROVIDE_HTTP_FETCH, NG21_PROVIDED_IN_ROOT, NG21_RESOURCE_API, NG21_SELF_CLOSING_TAGS, NG21_SIGNAL_CONTENT_CHILD, NG21_SIGNAL_FORMS_INTEROP, NG21_SIGNAL_INPUTS, NG21_SIGNAL_OUTPUTS, NG21_SIGNAL_STATE, NG21_SIGNAL_VIEW_CHILD, NG21_TEST_NO_DETECT_CHANGES_OUTSIDE, NG21_TEST_SIGNAL_INPUT, NG21_ZONELESS, } from "./angular21-snippets.js";
+const NG21_TAGS = ['angular', 'angular-21', 'modern'];
+const NG21_NEXT_COMMANDS = [
+    'shrk doctor',
+    'shrk task "<task>"',
+    'shrk ci scaffold github-actions --quickstart',
+];
+// ─── 1) Signals — state, queries, inputs, outputs, model ─────────────────
+export const ANGULAR_21_SIGNALS = definePreset({
+    id: 'angular-21-signals',
+    title: 'Angular 21 — signal-everything',
+    description: 'Signal-based local state, queries (viewChild / viewChildren / contentChild / contentChildren as functions), inputs (input() / input.required()), outputs (output()), and two-way bindings (model()). Replaces every @Input/@Output/@ViewChild decorator with its signal-era counterpart.',
+    tags: [...NG21_TAGS, 'signals'],
+    appliesTo: [WorkspaceProfile.HasAngular],
+    weight: 11,
+    includes: {
+        knowledge: [COMMON_AGENT_BRIEFING],
+        rules: [
+            COMMON_SAFETY_RULE,
+            NG21_SIGNAL_STATE,
+            NG21_LINKED_SIGNAL,
+            NG21_NO_EFFECT_FOR_DERIVED,
+            NG21_SIGNAL_VIEW_CHILD,
+            NG21_SIGNAL_CONTENT_CHILD,
+            NG21_SIGNAL_INPUTS,
+            NG21_SIGNAL_OUTPUTS,
+            NG21_MODEL_TWO_WAY,
+            NG21_SIGNAL_FORMS_INTEROP,
+        ],
+        paths: [ANGULAR_PATH_APP, ANGULAR_PATH_COMPONENTS, ANGULAR_PATH_SERVICES],
+        templates: [],
+        pipelines: [COMMON_PIPELINE_CONTEXT_ONLY, COMMON_PIPELINE_FEATURE_DEV],
+        docs: {
+            'overview.md': OVERVIEW_DOC('Angular 21 signals', 'No @Input, no @Output, no @ViewChild, no EventEmitter. Local state in signal(), derived in computed()/linkedSignal(), side effects in effect(), queries via viewChild()/contentChild(), I/O via input()/output()/model().'),
+        },
+    },
+    recommendedNextCommands: NG21_NEXT_COMMANDS,
+});
+// ─── 2) Zoneless ──────────────────────────────────────────────────────────
+export const ANGULAR_21_ZONELESS = definePreset({
+    id: 'angular-21-zoneless',
+    title: 'Angular 21 — zoneless change detection',
+    description: 'Bootstrap with provideZonelessChangeDetection() and remove zone.js entirely. Codifies the "no NgZone APIs, signals drive CD" posture, plus the migration hints (signal-first state, afterNextRender for DOM-aware work).',
+    tags: [...NG21_TAGS, 'zoneless', 'performance'],
+    appliesTo: [WorkspaceProfile.HasAngular],
+    weight: 11,
+    includes: {
+        knowledge: [COMMON_AGENT_BRIEFING],
+        rules: [
+            COMMON_SAFETY_RULE,
+            NG21_ZONELESS,
+            NG21_NO_ZONE_APIS,
+            NG21_SIGNAL_STATE,
+            NG21_AFTER_RENDER,
+            NG21_BOOTSTRAP_APPLICATION,
+            NG21_PROVIDE_HTTP_FETCH,
+        ],
+        paths: [ANGULAR_PATH_APP, ANGULAR_PATH_COMPONENTS, ANGULAR_PATH_SERVICES],
+        templates: [],
+        pipelines: [COMMON_PIPELINE_CONTEXT_ONLY, COMMON_PIPELINE_FEATURE_DEV],
+        docs: {
+            'overview.md': OVERVIEW_DOC('Angular 21 zoneless', 'CD runs when signals change, inputs update, or events fire — not on every microtask. No NgZone.run / runOutsideAngular. DOM-aware code uses afterNextRender(). HttpClient uses the fetch backend.'),
+        },
+    },
+    recommendedNextCommands: NG21_NEXT_COMMANDS,
+});
+// ─── 3) Modern control flow + template ergonomics ────────────────────────
+export const ANGULAR_21_CONTROL_FLOW = definePreset({
+    id: 'angular-21-control-flow',
+    title: 'Angular 21 — modern template control flow',
+    description: 'Built-in @if / @for / @switch / @defer / @let blocks instead of *ngIf / *ngFor / [ngSwitch], self-closing component tags, NgOptimizedImage. Includes the migration guidance for legacy templates.',
+    tags: [...NG21_TAGS, 'templates', 'control-flow'],
+    appliesTo: [WorkspaceProfile.HasAngular],
+    weight: 11,
+    includes: {
+        knowledge: [COMMON_AGENT_BRIEFING],
+        rules: [
+            COMMON_SAFETY_RULE,
+            NG21_CONTROL_FLOW,
+            NG21_DEFER,
+            NG21_LET_TEMPLATE,
+            NG21_SELF_CLOSING_TAGS,
+            NG21_NG_OPTIMIZED_IMAGE,
+        ],
+        paths: [ANGULAR_PATH_APP, ANGULAR_PATH_COMPONENTS],
+        templates: [],
+        pipelines: [COMMON_PIPELINE_CONTEXT_ONLY, COMMON_PIPELINE_FEATURE_DEV],
+        docs: {
+            'overview.md': OVERVIEW_DOC('Angular 21 control flow', '@if / @for (track is REQUIRED) / @switch / @defer / @let. Self-closing tags for content-less components. NgOptimizedImage with explicit width/height for every raster image.'),
+        },
+    },
+    recommendedNextCommands: [
+        ...NG21_NEXT_COMMANDS,
+        'ng generate @angular/core:control-flow',
+    ],
+});
+// ─── 4) Resource API — declarative async (signal-native) ─────────────────
+export const ANGULAR_21_RESOURCE = definePreset({
+    id: 'angular-21-resource',
+    title: 'Angular 21 — resource() / httpResource() / linkedSignal',
+    description: 'Declarative async state via resource() and httpResource(). Replaces the hand-rolled subscribe+loading+error triplet with a typed state machine driven by signals. Includes the linkedSignal pattern for writable derived values.',
+    tags: [...NG21_TAGS, 'async', 'resource'],
+    appliesTo: [WorkspaceProfile.HasAngular],
+    weight: 11,
+    includes: {
+        knowledge: [COMMON_AGENT_BRIEFING],
+        rules: [
+            COMMON_SAFETY_RULE,
+            NG21_RESOURCE_API,
+            NG21_HTTP_RESOURCE,
+            NG21_LINKED_SIGNAL,
+            NG21_PROVIDE_HTTP_FETCH,
+            NG21_SIGNAL_STATE,
+        ],
+        paths: [ANGULAR_PATH_SERVICES, ANGULAR_PATH_APP],
+        templates: [],
+        pipelines: [COMMON_PIPELINE_CONTEXT_ONLY, COMMON_PIPELINE_FEATURE_DEV],
+        docs: {
+            'overview.md': OVERVIEW_DOC('Angular 21 resource API', 'resource({ request, loader }) is the canonical async primitive — exposes value()/status()/error()/reload() as signals. httpResource(() => `/api/...`) for read endpoints. linkedSignal for writable state that follows a source.'),
+        },
+    },
+    recommendedNextCommands: NG21_NEXT_COMMANDS,
+});
+// ─── 5) Modern DI + lifecycle + bootstrap ────────────────────────────────
+export const ANGULAR_21_MODERN_DI = definePreset({
+    id: 'angular-21-modern-di',
+    title: 'Angular 21 — inject(), no NgModules, bootstrap modern',
+    description: 'inject() function over constructor parameters, providedIn root for tree-shakeable services, no new NgModules, bootstrapApplication() with the provideX() function family, afterNextRender() for DOM-aware lifecycle.',
+    tags: [...NG21_TAGS, 'di', 'lifecycle', 'bootstrap'],
+    appliesTo: [WorkspaceProfile.HasAngular],
+    weight: 11,
+    includes: {
+        knowledge: [COMMON_AGENT_BRIEFING],
+        rules: [
+            COMMON_SAFETY_RULE,
+            NG21_INJECT_FN,
+            NG21_PROVIDED_IN_ROOT,
+            NG21_NO_NGMODULES,
+            NG21_BOOTSTRAP_APPLICATION,
+            NG21_AFTER_RENDER,
+            NG21_PROVIDE_HTTP_FETCH,
+        ],
+        paths: [ANGULAR_PATH_APP, ANGULAR_PATH_SERVICES],
+        templates: [],
+        pipelines: [COMMON_PIPELINE_CONTEXT_ONLY, COMMON_PIPELINE_FEATURE_DEV],
+        docs: {
+            'overview.md': OVERVIEW_DOC('Angular 21 modern DI + bootstrap', 'inject() over constructor injection. @Injectable({ providedIn: "root" }) for tree-shakeable services. No new @NgModule. main.ts uses bootstrapApplication(AppComponent, { providers: [provideRouter, provideHttpClient(withFetch()), provideZonelessChangeDetection(), provideAnimationsAsync()] }).'),
+        },
+    },
+    recommendedNextCommands: NG21_NEXT_COMMANDS,
+});
+// ─── 6) The whole stack — composes all of the above ──────────────────────
+export const ANGULAR_21_MODERN = definePreset({
+    id: 'angular-21-modern',
+    title: 'Angular 21 — modern stack (signals + zoneless + control-flow + resource + DI)',
+    description: 'The canonical preset for a new Angular 21 app. Composes signals-everything, zoneless CD, modern control flow, resource() async, and inject()-based DI — plus the testing rules for signal inputs and SSR-safe HTTP. Use this unless you specifically want a narrower slice.',
+    tags: [...NG21_TAGS, 'comprehensive'],
+    appliesTo: [WorkspaceProfile.HasAngular, WorkspaceProfile.IsFrontend],
+    weight: 12,
+    composes: [
+        'angular-21-signals',
+        'angular-21-zoneless',
+        'angular-21-control-flow',
+        'angular-21-resource',
+        'angular-21-modern-di',
+    ],
+    includes: {
+        knowledge: [COMMON_AGENT_BRIEFING],
+        rules: [
+            COMMON_SAFETY_RULE,
+            // Extras that don't fit into any single focused preset:
+            NG21_HYBRID_RENDERING,
+            NG21_TEST_SIGNAL_INPUT,
+            NG21_TEST_NO_DETECT_CHANGES_OUTSIDE,
+        ],
+        paths: [ANGULAR_PATH_APP, ANGULAR_PATH_COMPONENTS, ANGULAR_PATH_SERVICES],
+        templates: [],
+        pipelines: [
+            COMMON_PIPELINE_CONTEXT_ONLY,
+            COMMON_PIPELINE_FEATURE_DEV,
+            COMMON_PIPELINE_UNIT_TEST,
+        ],
+        docs: {
+            'overview.md': OVERVIEW_DOC('Angular 21 modern stack', 'No decorators where a signal-era function exists. Zoneless CD. @if/@for/@defer/@let templates. resource() and httpResource() for async. inject() everywhere. bootstrapApplication with provideX functions — no NgModules. SSR via per-route RenderMode tags. Test signal inputs via fixture.componentRef.setInput().'),
+        },
+    },
+    recommendedNextCommands: [
+        'shrk doctor',
+        'shrk surface list',
+        'shrk task "<task>"',
+        'ng generate @angular/core:control-flow',
+        'ng generate @angular/core:signal-input-migration',
+        'ng generate @angular/core:signal-queries-migration',
+        'ng generate @angular/core:output-migration',
+    ],
+    surfaceProfile: 'small-app',
+});
+export const ANGULAR_21_PRESETS = Object.freeze([
+    ANGULAR_21_SIGNALS,
+    ANGULAR_21_ZONELESS,
+    ANGULAR_21_CONTROL_FLOW,
+    ANGULAR_21_RESOURCE,
+    ANGULAR_21_MODERN_DI,
+    ANGULAR_21_MODERN,
+]);

package/dist/builtin/angular21-snippets.d.ts

@@ -0,0 +1,28 @@
+export declare const NG21_SIGNAL_STATE: string;
+export declare const NG21_LINKED_SIGNAL: string;
+export declare const NG21_NO_EFFECT_FOR_DERIVED: string;
+export declare const NG21_SIGNAL_VIEW_CHILD: string;
+export declare const NG21_SIGNAL_CONTENT_CHILD: string;
+export declare const NG21_SIGNAL_INPUTS: string;
+export declare const NG21_SIGNAL_OUTPUTS: string;
+export declare const NG21_MODEL_TWO_WAY: string;
+export declare const NG21_ZONELESS: string;
+export declare const NG21_NO_ZONE_APIS: string;
+export declare const NG21_CONTROL_FLOW: string;
+export declare const NG21_DEFER: string;
+export declare const NG21_LET_TEMPLATE: string;
+export declare const NG21_SELF_CLOSING_TAGS: string;
+export declare const NG21_NG_OPTIMIZED_IMAGE: string;
+export declare const NG21_INJECT_FN: string;
+export declare const NG21_AFTER_RENDER: string;
+export declare const NG21_PROVIDED_IN_ROOT: string;
+export declare const NG21_NO_NGMODULES: string;
+export declare const NG21_BOOTSTRAP_APPLICATION: string;
+export declare const NG21_RESOURCE_API: string;
+export declare const NG21_HTTP_RESOURCE: string;
+export declare const NG21_HYBRID_RENDERING: string;
+export declare const NG21_PROVIDE_HTTP_FETCH: string;
+export declare const NG21_SIGNAL_FORMS_INTEROP: string;
+export declare const NG21_TEST_SIGNAL_INPUT: string;
+export declare const NG21_TEST_NO_DETECT_CHANGES_OUTSIDE: string;
+//# sourceMappingURL=angular21-snippets.d.ts.map

package/dist/builtin/angular21-snippets.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"angular21-snippets.d.ts","sourceRoot":"","sources":["../../src/builtin/angular21-snippets.ts"],"names":[],"mappings":"AAoBA,eAAO,MAAM,iBAAiB,QAQ5B,CAAC;AAEH,eAAO,MAAM,kBAAkB,QAQ7B,CAAC;AAEH,eAAO,MAAM,0BAA0B,QAQrC,CAAC;AAIH,eAAO,MAAM,sBAAsB,QAQjC,CAAC;AAEH,eAAO,MAAM,yBAAyB,QAQpC,CAAC;AAIH,eAAO,MAAM,kBAAkB,QAQ7B,CAAC;AAEH,eAAO,MAAM,mBAAmB,QAQ9B,CAAC;AAEH,eAAO,MAAM,kBAAkB,QAQ7B,CAAC;AAIH,eAAO,MAAM,aAAa,QAQxB,CAAC;AAEH,eAAO,MAAM,iBAAiB,QAQ5B,CAAC;AAIH,eAAO,MAAM,iBAAiB,QAQ5B,CAAC;AAEH,eAAO,MAAM,UAAU,QAQrB,CAAC;AAEH,eAAO,MAAM,iBAAiB,QAQ5B,CAAC;AAEH,eAAO,MAAM,sBAAsB,QAQjC,CAAC;AAEH,eAAO,MAAM,uBAAuB,QAQlC,CAAC;AAIH,eAAO,MAAM,cAAc,QAQzB,CAAC;AAEH,eAAO,MAAM,iBAAiB,QAQ5B,CAAC;AAEH,eAAO,MAAM,qBAAqB,QAQhC,CAAC;AAIH,eAAO,MAAM,iBAAiB,QAQ5B,CAAC;AAEH,eAAO,MAAM,0BAA0B,QAQrC,CAAC;AAIH,eAAO,MAAM,iBAAiB,QAQ5B,CAAC;AAEH,eAAO,MAAM,kBAAkB,QAQ7B,CAAC;AAIH,eAAO,MAAM,qBAAqB,QAQhC,CAAC;AAEH,eAAO,MAAM,uBAAuB,QAQlC,CAAC;AAIH,eAAO,MAAM,yBAAyB,QAQpC,CAAC;AAIH,eAAO,MAAM,sBAAsB,QAQjC,CAAC;AAEH,eAAO,MAAM,mCAAmC,QAQ9C,CAAC"}

package/dist/builtin/angular21-snippets.js

@@ -0,0 +1,243 @@
+// Modern Angular 18 / 19 / 20 / 21 rule snippets.
+//
+// Covers the post-decorators wave: signal-based reactivity, signal-based
+// queries (`viewChild()` / `contentChild()` etc.), signal-based I/O
+// (`input()` / `output()` / `model()`), zoneless change detection, the new
+// template control flow (`@if` / `@for` / `@switch` / `@defer` / `@let`),
+// `inject()` over constructor DI, `afterRender` / `afterNextRender`,
+// `resource()` / `httpResource()`, `linkedSignal`, `NgOptimizedImage`,
+// self-closing component tags, and the no-NgModules / hybrid-rendering
+// posture.
+//
+// Each snippet is a string injected verbatim into a generated
+// `sharkcraft/*.ts` file; `defineKnowledgeEntry`, `KnowledgeType`, and
+// `KnowledgePriority` are provided by the local-mirror preamble the
+// synthesizer prepends.
+import { ruleSnippet } from "./r26-snippets.js";
+// ─── Signal-based reactivity (Angular 16+, fully baked by 19/20) ──────────
+export const NG21_SIGNAL_STATE = ruleSnippet({
+    id: 'angular21.signal-state',
+    title: 'Local component state lives in signals',
+    priority: 'critical',
+    tags: ['angular', 'angular-21', 'signals'],
+    appliesWhen: ['generate-component', 'generate-code'],
+    content: 'Use signal() for every piece of component-local mutable state. Derive read-only values with computed(). Reserve effect() for side effects only (DOM imperative code, logging, external I/O) — never write to a signal from inside an effect.',
+});
+export const NG21_LINKED_SIGNAL = ruleSnippet({
+    id: 'angular21.linked-signal',
+    title: 'Use linkedSignal for writable derived state',
+    priority: 'high',
+    tags: ['angular', 'angular-21', 'signals'],
+    appliesWhen: ['generate-component', 'refactor'],
+    content: 'When you need a writable signal that resets whenever a source signal changes (e.g. a selection that follows a filtered list), use linkedSignal({ source, computation }) instead of an effect that pokes a writable signal — that pattern is officially discouraged.',
+});
+export const NG21_NO_EFFECT_FOR_DERIVED = ruleSnippet({
+    id: 'angular21.no-effect-for-derived',
+    title: 'Never derive state inside an effect()',
+    priority: 'critical',
+    tags: ['angular', 'angular-21', 'signals'],
+    appliesWhen: ['generate-code', 'review'],
+    content: 'If you find yourself writing effect(() => mySignal.set(compute(otherSignal()))), switch to computed() or linkedSignal(). Writing inside effects breaks single-source-of-truth and reintroduces the very glitches signals were designed to remove.',
+});
+// ─── Signal-based queries (Angular 17.2+) ─────────────────────────────────
+export const NG21_SIGNAL_VIEW_CHILD = ruleSnippet({
+    id: 'angular21.signal-view-child',
+    title: 'Use viewChild() / viewChildren() functions, not @ViewChild',
+    priority: 'critical',
+    tags: ['angular', 'angular-21', 'queries', 'signals'],
+    appliesWhen: ['generate-component', 'refactor'],
+    content: 'Replace @ViewChild and @ViewChildren with the viewChild() / viewChildren() functions. The signal form is reactive (you can pipe it through computed()/effect()), avoids the "expression has changed after it was checked" class of bug, and integrates with OnPush + zoneless out of the box. Use viewChild.required<ElementRef>("name") when the element is guaranteed.',
+});
+export const NG21_SIGNAL_CONTENT_CHILD = ruleSnippet({
+    id: 'angular21.signal-content-child',
+    title: 'Use contentChild() / contentChildren() functions, not @ContentChild',
+    priority: 'critical',
+    tags: ['angular', 'angular-21', 'queries', 'signals'],
+    appliesWhen: ['generate-component', 'refactor'],
+    content: 'Replace @ContentChild and @ContentChildren with the contentChild() / contentChildren() functions. Same reactivity story as viewChild — and contentChild() resolves at the same lifecycle moment regardless of static/dynamic, so you no longer need the {static: true} workaround.',
+});
+// ─── Signal-based inputs / outputs (Angular 17.1+ / 17.3+) ───────────────
+export const NG21_SIGNAL_INPUTS = ruleSnippet({
+    id: 'angular21.signal-inputs',
+    title: 'Use input() and input.required(), not @Input()',
+    priority: 'critical',
+    tags: ['angular', 'angular-21', 'inputs', 'signals'],
+    appliesWhen: ['generate-component', 'refactor'],
+    content: 'Declare inputs as `readonly user = input<User>()` or `readonly id = input.required<string>()` instead of @Input(). Signal inputs are read-only signals — call them as a function in the template (`{{ user() }}`) or pipe them through computed() in the class. Use the transform option for coerced inputs: `input(false, { transform: booleanAttribute })`.',
+});
+export const NG21_SIGNAL_OUTPUTS = ruleSnippet({
+    id: 'angular21.signal-outputs',
+    title: 'Use output(), not @Output() EventEmitter',
+    priority: 'critical',
+    tags: ['angular', 'angular-21', 'outputs', 'signals'],
+    appliesWhen: ['generate-component', 'refactor'],
+    content: 'Declare outputs as `readonly select = output<UserId>()` instead of `@Output() select = new EventEmitter<UserId>()`. The output() helper drops the RxJS dependency, is fully typed, and emits via `this.select.emit(id)`. It still composes with `outputToObservable()` when a stream is needed.',
+});
+export const NG21_MODEL_TWO_WAY = ruleSnippet({
+    id: 'angular21.model-two-way',
+    title: 'Use model() for two-way bindings',
+    priority: 'high',
+    tags: ['angular', 'angular-21', 'inputs', 'outputs', 'signals'],
+    appliesWhen: ['generate-component'],
+    content: 'For components that own a piece of state the parent wants to bind two-way, use `readonly value = model<string>("")`. Banana-in-a-box syntax (`[(value)]="x"`) wires up automatically — no manual @Input + @Output pair, no `valueChange` EventEmitter.',
+});
+// ─── Zoneless change detection (stable in Angular 21) ─────────────────────
+export const NG21_ZONELESS = ruleSnippet({
+    id: 'angular21.zoneless',
+    title: 'Configure zoneless change detection',
+    priority: 'critical',
+    tags: ['angular', 'angular-21', 'zoneless', 'performance'],
+    appliesWhen: ['bootstrap', 'configure'],
+    content: 'Bootstrap with provideZonelessChangeDetection() and remove `zone.js` from polyfills + angular.json. Once zoneless, change detection runs only when a signal changes, an input updates, an event handler fires, or a marked component opts in via markForCheck(). Verify by reading the platform: ApplicationRef.componentTypes should not include any zone-aware regressions.',
+});
+export const NG21_NO_ZONE_APIS = ruleSnippet({
+    id: 'angular21.no-zone-apis',
+    title: 'Do not call NgZone APIs in zoneless code',
+    priority: 'high',
+    tags: ['angular', 'angular-21', 'zoneless'],
+    appliesWhen: ['generate-code', 'review'],
+    content: 'In zoneless apps NgZone.run / runOutsideAngular are no-ops. Replace them with explicit ChangeDetectorRef.markForCheck() (rare), afterNextRender() for DOM-aware logic, or simply let the signal graph propagate.',
+});
+// ─── New template control flow (Angular 17+) ──────────────────────────────
+export const NG21_CONTROL_FLOW = ruleSnippet({
+    id: 'angular21.control-flow',
+    title: 'Use @if / @for / @switch, not *ngIf / *ngFor / [ngSwitch]',
+    priority: 'critical',
+    tags: ['angular', 'angular-21', 'templates'],
+    appliesWhen: ['generate-template', 'refactor'],
+    content: 'Built-in control flow is the canonical form. `@if`, `@else if`, `@else`; `@for (item of items; track item.id)` — track is REQUIRED, not optional; `@switch (x) { @case (\'a\') { … } @default { … } }`. Migrate legacy structural directives with `ng generate @angular/core:control-flow`.',
+});
+export const NG21_DEFER = ruleSnippet({
+    id: 'angular21.defer',
+    title: 'Use @defer for non-critical UI',
+    priority: 'high',
+    tags: ['angular', 'angular-21', 'templates', 'performance'],
+    appliesWhen: ['generate-template', 'optimize-bundle'],
+    content: 'Wrap heavy, below-the-fold, or interaction-gated UI in `@defer (on viewport)` / `(on hover)` / `(on idle)` / `(when condition())`. Pair with `@placeholder`, `@loading`, and `@error` blocks. Each @defer block is its own lazy-loaded chunk — no manual `loadComponent` plumbing needed.',
+});
+export const NG21_LET_TEMPLATE = ruleSnippet({
+    id: 'angular21.let-template',
+    title: 'Use @let for template-local values',
+    priority: 'medium',
+    tags: ['angular', 'angular-21', 'templates'],
+    appliesWhen: ['generate-template'],
+    content: 'Introduce template-scoped names with `@let total = items().reduce(...)`. This replaces the `*ngIf="x as y"` aliasing trick — works anywhere in the template, no implicit-element baggage.',
+});
+export const NG21_SELF_CLOSING_TAGS = ruleSnippet({
+    id: 'angular21.self-closing-tags',
+    title: 'Self-close components with no content children',
+    priority: 'low',
+    tags: ['angular', 'angular-21', 'templates'],
+    appliesWhen: ['generate-template'],
+    content: 'Components / directives that take no projected content should be written `<app-foo [x]="y" />`, not `<app-foo …></app-foo>`. Saves a token and matches modern Angular / JSX conventions.',
+});
+export const NG21_NG_OPTIMIZED_IMAGE = ruleSnippet({
+    id: 'angular21.ng-optimized-image',
+    title: 'Use NgOptimizedImage for raster images',
+    priority: 'high',
+    tags: ['angular', 'angular-21', 'performance', 'a11y'],
+    appliesWhen: ['generate-template'],
+    content: 'Replace `<img src="...">` with `<img ngSrc="..." width="…" height="…" priority? />`. NgOptimizedImage adds automatic responsive `srcset`, lazy-loads non-priority images, sets fetchpriority on LCP images, and enforces explicit dimensions to prevent layout shift.',
+});
+// ─── inject(), afterRender, modern lifecycle (Angular 14+ / 16+) ──────────
+export const NG21_INJECT_FN = ruleSnippet({
+    id: 'angular21.inject-fn',
+    title: 'Use inject(), not constructor parameters',
+    priority: 'high',
+    tags: ['angular', 'angular-21', 'di'],
+    appliesWhen: ['generate-component', 'generate-service', 'refactor'],
+    content: 'Default to `private readonly users = inject(UsersService)` over constructor-parameter injection. Required for functional guards / interceptors, makes inheritance straightforward, and removes the need for `@Self()` / `@SkipSelf()` / `@Optional()` decorator stacks (use the options bag instead).',
+});
+export const NG21_AFTER_RENDER = ruleSnippet({
+    id: 'angular21.after-render',
+    title: 'Use afterNextRender / afterRender for DOM-aware logic',
+    priority: 'high',
+    tags: ['angular', 'angular-21', 'lifecycle'],
+    appliesWhen: ['generate-component'],
+    content: 'For code that needs the DOM (measuring, focusing, third-party libs): use afterNextRender(() => …) for one-shot setup or afterRender(() => …) for every CD pass. Both run only in the browser, so they\'re SSR-safe by construction — replacing the ngAfterViewInit + isPlatformBrowser dance.',
+});
+export const NG21_PROVIDED_IN_ROOT = ruleSnippet({
+    id: 'angular21.provided-in-root',
+    title: 'Services use providedIn: \'root\' (tree-shakeable)',
+    priority: 'high',
+    tags: ['angular', 'angular-21', 'di', 'services'],
+    appliesWhen: ['generate-service'],
+    content: 'Inject services via `@Injectable({ providedIn: "root" })` so unused services tree-shake out. Only override with component / route providers when you need a fresh instance per consumer.',
+});
+// ─── No NgModules / standalone-only ───────────────────────────────────────
+export const NG21_NO_NGMODULES = ruleSnippet({
+    id: 'angular21.no-ngmodules',
+    title: 'Do not create new NgModules',
+    priority: 'critical',
+    tags: ['angular', 'angular-21', 'architecture'],
+    appliesWhen: ['generate-code', 'create-feature'],
+    content: 'Angular 21 starter apps are NgModule-free. Components, directives, and pipes are standalone by default (the `standalone: true` flag is the default since v19). Configure providers via `provideX()` functions in bootstrapApplication() or route data, never with @NgModule. If you find yourself writing @NgModule, you are working against the grain.',
+});
+export const NG21_BOOTSTRAP_APPLICATION = ruleSnippet({
+    id: 'angular21.bootstrap-application',
+    title: 'bootstrap via bootstrapApplication + provideX functions',
+    priority: 'high',
+    tags: ['angular', 'angular-21', 'bootstrap'],
+    appliesWhen: ['bootstrap'],
+    content: 'main.ts uses bootstrapApplication(AppComponent, { providers: [provideRouter(routes), provideHttpClient(withFetch()), provideZonelessChangeDetection(), provideAnimationsAsync()] }). Each capability has a provideX() — no AppModule needed.',
+});
+// ─── Async data: resource() / httpResource() (Angular 19/20+) ────────────
+export const NG21_RESOURCE_API = ruleSnippet({
+    id: 'angular21.resource-api',
+    title: 'Model async state with resource()',
+    priority: 'high',
+    tags: ['angular', 'angular-21', 'async', 'signals'],
+    appliesWhen: ['generate-component', 'generate-service'],
+    content: 'For "fetch X based on signal Y" patterns, use resource({ request: () => y(), loader: ({ request, abortSignal }) => fetch(...) }). The resource exposes `.value()`, `.status()`, `.error()`, and `.reload()` — a fully-typed state machine driven by signals. Don\'t hand-roll subscription + loading-state + error-state triplets anymore.',
+});
+export const NG21_HTTP_RESOURCE = ruleSnippet({
+    id: 'angular21.http-resource',
+    title: 'Use httpResource() for declarative HTTP',
+    priority: 'high',
+    tags: ['angular', 'angular-21', 'http', 'signals'],
+    appliesWhen: ['generate-service'],
+    content: 'For straight reads, `const user = httpResource<User>(() => \\`/api/users/${id()}\\`)` replaces an HttpClient.get + BehaviorSubject + loading flag triple. The signal in the URL closure is tracked; updating it refetches.',
+});
+// ─── Modern SSR / hybrid rendering (Angular 19+) ─────────────────────────
+export const NG21_HYBRID_RENDERING = ruleSnippet({
+    id: 'angular21.hybrid-rendering',
+    title: 'Configure routes with server-rendering modes',
+    priority: 'medium',
+    tags: ['angular', 'angular-21', 'ssr'],
+    appliesWhen: ['configure-routes'],
+    content: 'In app.routes.server.ts, tag each route with a RenderMode: `Prerender` for static, `Server` for per-request SSR, `Client` for CSR-only. The default `provideServerRouting(serverRoutes)` enforces the boundary — no more "did this code accidentally run on the server?" guesswork.',
+});
+export const NG21_PROVIDE_HTTP_FETCH = ruleSnippet({
+    id: 'angular21.provide-http-fetch',
+    title: 'provideHttpClient(withFetch()) — never the XHR backend',
+    priority: 'high',
+    tags: ['angular', 'angular-21', 'http', 'ssr'],
+    appliesWhen: ['configure'],
+    content: 'Provide HttpClient with the fetch backend (`provideHttpClient(withFetch())`). XHR breaks under SSR and pays a startup cost; fetch is universal, supports streaming, and is required for resource transfer between server and client.',
+});
+// ─── Forms — modern signal-compatible patterns ───────────────────────────
+export const NG21_SIGNAL_FORMS_INTEROP = ruleSnippet({
+    id: 'angular21.signal-forms-interop',
+    title: 'Bridge reactive forms into signals with toSignal()',
+    priority: 'medium',
+    tags: ['angular', 'angular-21', 'forms', 'signals'],
+    appliesWhen: ['generate-component'],
+    content: 'When you need a form value as a signal, do `const value = toSignal(form.valueChanges, { initialValue: form.getRawValue() })`. Don\'t mix .subscribe() into a component that otherwise relies on signal-driven CD — that subscription will leak.',
+});
+// ─── Testing — modern flow ───────────────────────────────────────────────
+export const NG21_TEST_SIGNAL_INPUT = ruleSnippet({
+    id: 'angular21.test-signal-input',
+    title: 'Set signal inputs in tests via setInput()',
+    priority: 'medium',
+    tags: ['angular', 'angular-21', 'testing'],
+    appliesWhen: ['generate-test'],
+    content: 'In TestBed, set signal-input values with `fixture.componentRef.setInput("user", u)` — not by assigning `component.user`. Detection runs only when the input signal is updated, and setInput is the supported path that triggers it.',
+});
+export const NG21_TEST_NO_DETECT_CHANGES_OUTSIDE = ruleSnippet({
+    id: 'angular21.test-no-detect-changes-outside',
+    title: 'Let the framework drive CD in tests',
+    priority: 'low',
+    tags: ['angular', 'angular-21', 'testing'],
+    appliesWhen: ['generate-test'],
+    content: 'In zoneless tests, call `fixture.detectChanges()` only at deliberate "settle" points; signal updates inside the test run schedule the next CD automatically. Sprinkling detectChanges() after every assignment masks real reactivity bugs.',
+});

package/dist/builtin/builtin-presets.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"builtin-presets.d.ts","sourceRoot":"","sources":["../../src/builtin/builtin-presets.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,oBAAoB,CAAC;AA6iBlD,eAAO,MAAM,eAAe,EAAE,SAAS,OAAO,EA0B5C,CAAC"}
+{"version":3,"file":"builtin-presets.d.ts","sourceRoot":"","sources":["../../src/builtin/builtin-presets.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,oBAAoB,CAAC;AA8jBlD,eAAO,MAAM,eAAe,EAAE,SAAS,OAAO,EA4C5C,CAAC"}