@lankajs/angular 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 lankajs contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,46 @@
+# @lankajs/angular
+
+**▸ module** · Angular binding
+
+> One function — `useLankaVM` — over a signal, and the access tracking core already does.
+
+A library in the same box. The app imports and calls it; core does not know it exists.
+
+**Runs in:** the browser.
+
+**Requires:** Angular. Enforced by `check-runtime.mjs`, which refuses an import of any other.
+
+**How to use it:** [GUIDE.md](./GUIDE.md) — the user guide, with examples. **How to change it:** [SKILL.md](./SKILL.md).
+
+## Contents
+
+- `useLankaVM` — the one name, and the same one every member of this shelf publishes
+
+## What an Angular call answers
+
+A `Signal`: `state().rows` in a component, `{{ state().rows }}` in a template. Zoneless
+works with no extra step, because a signal is what zoneless change detection reads.
+
+## The injection context, and why it is required rather than optional
+
+`useLankaVM` must be called where Angular can inject — a constructor, a field
+initialiser, a factory, or inside `runInInjectionContext`. It asserts that, and the
+message names the fix.
+
+That is stricter than the Vue and Solid bindings, which publish a `stop()` for a call
+made outside their scope. Angular's reason is different: `DestroyRef` is the ONLY way
+to know when the caller goes away, and a subscription with no way to learn that is a
+leak with no owner. Where Vue and Solid degrade, Angular refuses — and refusing at the
+call is better than a leak discovered in production.
+
+## The injection context reaches a test too
+
+`renderWithLanka` from `@lankajs/angular/testing` renders a component with a live
+framework behind it, the way every other member of this shelf does. What differs is
+underneath: Angular Testing Library drives `TestBed`, so a component here is compiled
+rather than merely mounted — and a ViewModel read in a field initialiser is inside an
+injection context, which is the one thing this binding insists on.
+
+---
+
+Repository map: [../../../README.md](../../../README.md)

package/dist/chunk-5WRI5ZAA.js

@@ -0,0 +1,31 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __commonJS = (cb, mod) => function __require() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+
+export {
+  __commonJS,
+  __toESM
+};
+//# sourceMappingURL=chunk-5WRI5ZAA.js.map

package/dist/chunk-5WRI5ZAA.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/dist/index.d.ts

@@ -0,0 +1,166 @@
+import { ILankaReadableVM } from 'lanka/viewmodel';
+import { Signal } from '@angular/core';
+
+/** What a subscriber hands in, and what it gets back. */
+interface ILankaObserver<TValue> {
+    next?: (value: TValue) => void;
+    error?: (failure: unknown) => void;
+    complete?: () => void;
+}
+/** What unsubscribing looks like, in RxJS's own vocabulary. */
+interface ILankaUnsubscribable {
+    unsubscribe: () => void;
+}
+/**
+ * A ViewModel as something the `async` pipe and an RxJS chain accept.
+ *
+ * `Subscribable` is the whole contract: one method, and `AsyncPipe` takes it as
+ * readily as an `Observable`.
+ */
+interface ILankaObservableVM<TState extends object> {
+    subscribe: (observer: ILankaObserver<TState> | ((value: TState) => void)) => ILankaUnsubscribable;
+}
+/**
+ * Reads a ViewModel as a stream, for the half of Angular that speaks RxJS.
+ *
+ * ```ts
+ * @Component({ template: `@if (todos$ | async; as todos) { … }` })
+ * export class TodoScreen {
+ * 	protected readonly todos$ = toLankaObservable(todosVM);
+ * }
+ * ```
+ *
+ * ```ts
+ * // or in a chain, where signals cannot go
+ * toLankaObservable(todosVM).subscribe(({ rows }) => this.log(rows.length));
+ * ```
+ *
+ * ## Why this exists beside `useLankaVM` and `toLankaSignals`
+ *
+ * Angular is signals-first now and those two answer signals, which is the right
+ * default. It is also a framework with fifteen years of `Observable` in it: the
+ * `async` pipe, `HttpClient`, the router's events, every `switchMap` a codebase
+ * already has. A consumer with a stream in hand reaches for `combineLatest`, and
+ * a signal is not something they can pass to it.
+ *
+ * ## No `rxjs` import, deliberately
+ *
+ * `AsyncPipe` accepts `Subscribable<T>`, which is an INTERFACE — one method — so
+ * this satisfies it structurally and adds no dependency. The parity canon's
+ * order for an idiom is the framework's own library first, then what it already
+ * requires, then a few lines written here, and only then somebody else's
+ * package. This is the third rung, and it keeps `@lankajs/angular` importing
+ * nothing but `@angular/core`.
+ *
+ * A consumer who wants the operators pipes it: `from(toLankaObservable(vm))`
+ * takes a subscribable, and `toObservable` from `@angular/core/rxjs-interop`
+ * takes the signal `useLankaVM` answers.
+ *
+ * ## It emits the CURRENT state first
+ *
+ * Like a `BehaviorSubject` and like every store an Angular consumer has met: a
+ * subscriber gets the state it subscribed to before anything changes, because a
+ * template rendering `| async` would otherwise show nothing until the first
+ * write.
+ *
+ * ## No injection context needed
+ *
+ * Unlike `useLankaVM` and `toLankaSignals`, which take a `DestroyRef` because a
+ * signal has no other way to learn its reader has gone. A stream's subscriber
+ * holds its own unsubscribe, which is RxJS's answer to the same question — so
+ * this works in a service, a resolver, an interceptor and a plain function.
+ */
+declare const toLankaObservable: <TState extends object>(viewModel: ILankaReadableVM<TState>) => ILankaObservableVM<TState>;
+
+/**
+ * A ViewModel split the way an Angular service exposes state: a signal per
+ * value, and the actions as themselves.
+ *
+ * An action is one object for the life of the store, so wrapping it in a signal
+ * would make every call site write `load()()`. A value changes, so it is a
+ * signal; a function does not, so it is a function.
+ */
+type TLankaSignals<TState extends object> = {
+    [TKey in keyof TState]: TState[TKey] extends (...args: never[]) => unknown ? TState[TKey] : Signal<TState[TKey]>;
+};
+/**
+ * Reads a ViewModel as the signals an Angular component expects.
+ *
+ * ```ts
+ * @Component({ template: `@if (todos.isLoading()) { … } @for (row of todos.rows(); track row) { … }` })
+ * export class TodoScreen {
+ * 	protected readonly todos = toLankaSignals(todosVM);
+ * }
+ * ```
+ *
+ * ## Why this exists beside `useLankaVM`
+ *
+ * `useLankaVM` answers ONE `Signal` over the whole state, which is the shape
+ * every other binding on the shelf parallels: `state().rows`. It is also not how
+ * Angular holds state. An Angular service exposes a signal per field —
+ * `readonly rows = signal([])` — and a template reads `rows()`, never
+ * `state().rows`. A consumer with that habit reaches for `todos.rows()` and finds
+ * a call on a plain object.
+ *
+ * ## One subscription, and each signal is a `computed` over it
+ *
+ * There is one `subscribe` on the ViewModel and one version signal behind every
+ * field, so a change wakes Angular once and each `computed` decides for itself
+ * whether its own value moved. That is Angular's own deduplication — a `computed`
+ * whose result is unchanged notifies nobody — arriving for free, and it is why
+ * this is not a second subscription per field.
+ *
+ * ## The keys are read ONCE, at the call
+ *
+ * A ViewModel declares its state up front, so the field list is fixed at the
+ * moment this is called. A key added to the state later has no signal here, and
+ * that is the price of the shape: Angular's own services name their fields too.
+ * `useLankaVM` is the answer for a state whose shape is genuinely dynamic.
+ *
+ * ## It needs an injection context, for the reason `useLankaVM` does
+ *
+ * `DestroyRef` is the only way to learn the caller has gone, and a subscription
+ * that cannot learn that is a leak with no owner.
+ */
+declare const toLankaSignals: <TState extends object>(viewModel: ILankaReadableVM<TState>) => TLankaSignals<TState>;
+
+/**
+ * Reads a ViewModel from Angular.
+ *
+ * ```ts
+ * @Component({ template: `<li *ngFor="let row of state().rows">{{ row }}</li>` })
+ * export class TodoScreen {
+ * 	protected readonly state = useLankaVM(todoVM);
+ * }
+ * ```
+ *
+ * Without a selector the signal carries a value that RECORDS which keys were
+ * read, and changes only when one of THOSE moves. With a selector the selector
+ * decides and tracking is bypassed.
+ *
+ * Zoneless needs no extra step: a signal is what zoneless change detection
+ * reads, so this is the shape Angular is moving towards rather than a bridge to
+ * it.
+ *
+ * ## Why an injection context is REQUIRED, not preferred
+ *
+ * `@lankajs/vue` and `@lankajs/solid` publish a `stop()` for a call made outside
+ * their framework's scope, because both can still work without one. Angular
+ * cannot: `DestroyRef` is the only way to learn that the caller has gone, and a
+ * subscription with no way to learn that is a leak with no owner.
+ *
+ * So this refuses at the call rather than leaking quietly, and the message names
+ * the fix. Where the other two degrade, this one stops — and a refusal a
+ * developer reads once beats a leak found in production.
+ *
+ * ## What this function does NOT contain
+ *
+ * The recording, the comparison and the blind-spot warning are
+ * `createLankaAccessTracker` in core. Every binding on this shelf calls it,
+ * which is what makes "a screen updates for the keys it read" a fact about lanka
+ * rather than a fact about Angular.
+ */
+declare function useLankaVM<TState extends object>(viewModel: ILankaReadableVM<TState>): Signal<TState>;
+declare function useLankaVM<TState extends object, TSelected>(viewModel: ILankaReadableVM<TState>, selector: (state: TState) => TSelected): Signal<TSelected>;
+
+export { type ILankaObservableVM, type ILankaObserver, type ILankaUnsubscribable, type TLankaSignals, toLankaObservable, toLankaSignals, useLankaVM };

package/dist/index.js

@@ -0,0 +1,63 @@
+import "./chunk-5WRI5ZAA.js";
+
+// src/to-lanka-observable/toLankaObservable.ts
+import { createLankaViewSubscription } from "lanka/extend";
+var toLankaObservable = (viewModel) => ({
+  subscribe: (observer) => {
+    const next = typeof observer === "function" ? observer : observer.next ?? (() => void 0);
+    const view = createLankaViewSubscription(viewModel, () => next(view.read()));
+    next(view.read());
+    return { unsubscribe: view.stop };
+  }
+});
+
+// src/to-lanka-signals/toLankaSignals.ts
+import { DestroyRef, assertInInjectionContext, computed, inject, signal } from "@angular/core";
+import { createLankaViewSubscription as createLankaViewSubscription2 } from "lanka/extend";
+var toLankaSignals = (viewModel) => {
+  assertInInjectionContext(toLankaSignals);
+  const version = signal(0);
+  const view = createLankaViewSubscription2(viewModel, () => {
+    version.update((seen) => seen + 1);
+  });
+  inject(DestroyRef).onDestroy(view.stop);
+  const signals = {};
+  for (const [key, value] of Object.entries(viewModel.getState())) {
+    signals[key] = typeof value === "function" ? value : computed(() => {
+      version();
+      return view.read()[key];
+    });
+  }
+  return signals;
+};
+
+// src/use-lanka-vm/useLankaVM.ts
+import { DestroyRef as DestroyRef2, assertInInjectionContext as assertInInjectionContext2, inject as inject2, signal as signal2 } from "@angular/core";
+import { createLankaAccessTracker } from "lanka/extend";
+function useLankaVM(viewModel, selector) {
+  assertInInjectionContext2(useLankaVM);
+  const tracker = createLankaAccessTracker(viewModel);
+  const read = () => selector ? selector(viewModel.getState()) : tracker.read();
+  const state = signal2(read(), { equal: () => false });
+  const stop = viewModel.subscribe((next, prev) => {
+    if (selector) {
+      const picked = read();
+      if (Object.is(picked, state())) return;
+      state.set(picked);
+      return;
+    }
+    if (!tracker.shouldNotify(next, prev)) {
+      tracker.reportSkipped(next, prev);
+      return;
+    }
+    state.set(read());
+  });
+  inject2(DestroyRef2).onDestroy(stop);
+  return state.asReadonly();
+}
+export {
+  toLankaObservable,
+  toLankaSignals,
+  useLankaVM
+};
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/to-lanka-observable/toLankaObservable.ts","../src/to-lanka-signals/toLankaSignals.ts","../src/use-lanka-vm/useLankaVM.ts"],"sourcesContent":["import { createLankaViewSubscription } from \"lanka/extend\";\nimport type { ILankaReadableVM } from \"lanka/viewmodel\";\n\n/** What a subscriber hands in, and what it gets back. */\nexport interface ILankaObserver<TValue> {\n\tnext?: (value: TValue) => void;\n\terror?: (failure: unknown) => void;\n\tcomplete?: () => void;\n}\n\n/** What unsubscribing looks like, in RxJS's own vocabulary. */\nexport interface ILankaUnsubscribable {\n\tunsubscribe: () => void;\n}\n\n/**\n * A ViewModel as something the `async` pipe and an RxJS chain accept.\n *\n * `Subscribable` is the whole contract: one method, and `AsyncPipe` takes it as\n * readily as an `Observable`.\n */\nexport interface ILankaObservableVM<TState extends object> {\n\tsubscribe: (\n\t\tobserver: ILankaObserver<TState> | ((value: TState) => void),\n\t) => ILankaUnsubscribable;\n}\n\n/**\n * Reads a ViewModel as a stream, for the half of Angular that speaks RxJS.\n *\n * ```ts\n * @Component({ template: `@if (todos$ | async; as todos) { … }` })\n * export class TodoScreen {\n * \tprotected readonly todos$ = toLankaObservable(todosVM);\n * }\n * ```\n *\n * ```ts\n * // or in a chain, where signals cannot go\n * toLankaObservable(todosVM).subscribe(({ rows }) => this.log(rows.length));\n * ```\n *\n * ## Why this exists beside `useLankaVM` and `toLankaSignals`\n *\n * Angular is signals-first now and those two answer signals, which is the right\n * default. It is also a framework with fifteen years of `Observable` in it: the\n * `async` pipe, `HttpClient`, the router's events, every `switchMap` a codebase\n * already has. A consumer with a stream in hand reaches for `combineLatest`, and\n * a signal is not something they can pass to it.\n *\n * ## No `rxjs` import, deliberately\n *\n * `AsyncPipe` accepts `Subscribable<T>`, which is an INTERFACE — one method — so\n * this satisfies it structurally and adds no dependency. The parity canon's\n * order for an idiom is the framework's own library first, then what it already\n * requires, then a few lines written here, and only then somebody else's\n * package. This is the third rung, and it keeps `@lankajs/angular` importing\n * nothing but `@angular/core`.\n *\n * A consumer who wants the operators pipes it: `from(toLankaObservable(vm))`\n * takes a subscribable, and `toObservable` from `@angular/core/rxjs-interop`\n * takes the signal `useLankaVM` answers.\n *\n * ## It emits the CURRENT state first\n *\n * Like a `BehaviorSubject` and like every store an Angular consumer has met: a\n * subscriber gets the state it subscribed to before anything changes, because a\n * template rendering `| async` would otherwise show nothing until the first\n * write.\n *\n * ## No injection context needed\n *\n * Unlike `useLankaVM` and `toLankaSignals`, which take a `DestroyRef` because a\n * signal has no other way to learn its reader has gone. A stream's subscriber\n * holds its own unsubscribe, which is RxJS's answer to the same question — so\n * this works in a service, a resolver, an interceptor and a plain function.\n */\nexport const toLankaObservable = <TState extends object>(\n\tviewModel: ILankaReadableVM<TState>,\n): ILankaObservableVM<TState> => ({\n\tsubscribe: (observer) => {\n\t\tconst next =\n\t\t\ttypeof observer === \"function\" ? observer : (observer.next ?? (() => undefined));\n\n\t\tconst view = createLankaViewSubscription(viewModel, () => next(view.read()));\n\n\t\tnext(view.read());\n\n\t\treturn { unsubscribe: view.stop };\n\t},\n});\n","import { DestroyRef, assertInInjectionContext, computed, inject, signal } from \"@angular/core\";\nimport { createLankaViewSubscription } from \"lanka/extend\";\nimport type { Signal } from \"@angular/core\";\nimport type { ILankaReadableVM } from \"lanka/viewmodel\";\n\n/**\n * A ViewModel split the way an Angular service exposes state: a signal per\n * value, and the actions as themselves.\n *\n * An action is one object for the life of the store, so wrapping it in a signal\n * would make every call site write `load()()`. A value changes, so it is a\n * signal; a function does not, so it is a function.\n */\nexport type TLankaSignals<TState extends object> = {\n\t[TKey in keyof TState]: TState[TKey] extends (...args: never[]) => unknown\n\t\t? TState[TKey]\n\t\t: Signal<TState[TKey]>;\n};\n\n/**\n * Reads a ViewModel as the signals an Angular component expects.\n *\n * ```ts\n * @Component({ template: `@if (todos.isLoading()) { … } @for (row of todos.rows(); track row) { … }` })\n * export class TodoScreen {\n * \tprotected readonly todos = toLankaSignals(todosVM);\n * }\n * ```\n *\n * ## Why this exists beside `useLankaVM`\n *\n * `useLankaVM` answers ONE `Signal` over the whole state, which is the shape\n * every other binding on the shelf parallels: `state().rows`. It is also not how\n * Angular holds state. An Angular service exposes a signal per field —\n * `readonly rows = signal([])` — and a template reads `rows()`, never\n * `state().rows`. A consumer with that habit reaches for `todos.rows()` and finds\n * a call on a plain object.\n *\n * ## One subscription, and each signal is a `computed` over it\n *\n * There is one `subscribe` on the ViewModel and one version signal behind every\n * field, so a change wakes Angular once and each `computed` decides for itself\n * whether its own value moved. That is Angular's own deduplication — a `computed`\n * whose result is unchanged notifies nobody — arriving for free, and it is why\n * this is not a second subscription per field.\n *\n * ## The keys are read ONCE, at the call\n *\n * A ViewModel declares its state up front, so the field list is fixed at the\n * moment this is called. A key added to the state later has no signal here, and\n * that is the price of the shape: Angular's own services name their fields too.\n * `useLankaVM` is the answer for a state whose shape is genuinely dynamic.\n *\n * ## It needs an injection context, for the reason `useLankaVM` does\n *\n * `DestroyRef` is the only way to learn the caller has gone, and a subscription\n * that cannot learn that is a leak with no owner.\n */\nexport const toLankaSignals = <TState extends object>(\n\tviewModel: ILankaReadableVM<TState>,\n): TLankaSignals<TState> => {\n\tassertInInjectionContext(toLankaSignals);\n\n\tconst version = signal(0);\n\tconst view = createLankaViewSubscription(viewModel, () => {\n\t\tversion.update((seen) => seen + 1);\n\t});\n\n\tinject(DestroyRef).onDestroy(view.stop);\n\n\tconst signals = {} as Record<string, unknown>;\n\n\tfor (const [key, value] of Object.entries(viewModel.getState())) {\n\t\tsignals[key] =\n\t\t\ttypeof value === \"function\"\n\t\t\t\t? value\n\t\t\t\t: computed(() => {\n\t\t\t\t\t\t// Read for the DEPENDENCY, discard the number. The value itself\n\t\t\t\t\t\t// comes from a tracked read, so the key is recorded and this reader\n\t\t\t\t\t\t// is woken only for the keys it has signals for.\n\t\t\t\t\t\tversion();\n\n\t\t\t\t\t\treturn (view.read() as Record<string, unknown>)[key];\n\t\t\t\t\t});\n\t}\n\n\treturn signals as TLankaSignals<TState>;\n};\n","import { DestroyRef, assertInInjectionContext, inject, signal } from \"@angular/core\";\nimport { createLankaAccessTracker } from \"lanka/extend\";\nimport type { Signal } from \"@angular/core\";\nimport type { ILankaReadableVM } from \"lanka/viewmodel\";\n\n/**\n * Reads a ViewModel from Angular.\n *\n * ```ts\n * @Component({ template: `<li *ngFor=\"let row of state().rows\">{{ row }}</li>` })\n * export class TodoScreen {\n * \tprotected readonly state = useLankaVM(todoVM);\n * }\n * ```\n *\n * Without a selector the signal carries a value that RECORDS which keys were\n * read, and changes only when one of THOSE moves. With a selector the selector\n * decides and tracking is bypassed.\n *\n * Zoneless needs no extra step: a signal is what zoneless change detection\n * reads, so this is the shape Angular is moving towards rather than a bridge to\n * it.\n *\n * ## Why an injection context is REQUIRED, not preferred\n *\n * `@lankajs/vue` and `@lankajs/solid` publish a `stop()` for a call made outside\n * their framework's scope, because both can still work without one. Angular\n * cannot: `DestroyRef` is the only way to learn that the caller has gone, and a\n * subscription with no way to learn that is a leak with no owner.\n *\n * So this refuses at the call rather than leaking quietly, and the message names\n * the fix. Where the other two degrade, this one stops — and a refusal a\n * developer reads once beats a leak found in production.\n *\n * ## What this function does NOT contain\n *\n * The recording, the comparison and the blind-spot warning are\n * `createLankaAccessTracker` in core. Every binding on this shelf calls it,\n * which is what makes \"a screen updates for the keys it read\" a fact about lanka\n * rather than a fact about Angular.\n */\nexport function useLankaVM<TState extends object>(\n\tviewModel: ILankaReadableVM<TState>,\n): Signal<TState>;\n\nexport function useLankaVM<TState extends object, TSelected>(\n\tviewModel: ILankaReadableVM<TState>,\n\tselector: (state: TState) => TSelected,\n): Signal<TSelected>;\n\nexport function useLankaVM<TState extends object, TSelected>(\n\tviewModel: ILankaReadableVM<TState>,\n\tselector?: (state: TState) => TSelected,\n): Signal<TState | TSelected> {\n\tassertInInjectionContext(useLankaVM);\n\n\tconst tracker = createLankaAccessTracker(viewModel);\n\tconst read = (): TState | TSelected =>\n\t\tselector ? selector(viewModel.getState()) : tracker.read();\n\n\t// `equal: () => false` because a tracked read hands back the SAME proxy while\n\t// the state object is unchanged, and a signal compares by identity — so\n\t// setting it would be a no-op exactly when the tracker did its job. What\n\t// decides whether anything happens is `shouldNotify` below, which is the\n\t// framework's answer rather than the signal's.\n\tconst state = signal<TState | TSelected>(read(), { equal: () => false });\n\n\tconst stop = viewModel.subscribe((next, prev) => {\n\t\tif (selector) {\n\t\t\tconst picked = read();\n\n\t\t\t// Only when the SELECTION moved. The signal is `equal: () => false`, so\n\t\t\t// setting it always wakes — which is right for a tracked read and wrong\n\t\t\t// for a selected one, and is what the suite's selector scenes refuse.\n\t\t\tif (Object.is(picked, state())) return;\n\n\t\t\tstate.set(picked);\n\n\t\t\treturn;\n\t\t}\n\n\t\tif (!tracker.shouldNotify(next, prev)) {\n\t\t\t// No update will follow. If the changed key is linked to this component\n\t\t\t// through a getter it read, the screen froze — and in development core\n\t\t\t// says so by name.\n\t\t\ttracker.reportSkipped(next, prev);\n\t\t\treturn;\n\t\t}\n\n\t\tstate.set(read());\n\t});\n\tinject(DestroyRef).onDestroy(stop);\n\n\treturn state.asReadonly();\n}\n"],"mappings":";;;AAAA,SAAS,mCAAmC;AA6ErC,IAAM,oBAAoB,CAChC,eACiC;AAAA,EACjC,WAAW,CAAC,aAAa;AACxB,UAAM,OACL,OAAO,aAAa,aAAa,WAAY,SAAS,SAAS,MAAM;AAEtE,UAAM,OAAO,4BAA4B,WAAW,MAAM,KAAK,KAAK,KAAK,CAAC,CAAC;AAE3E,SAAK,KAAK,KAAK,CAAC;AAEhB,WAAO,EAAE,aAAa,KAAK,KAAK;AAAA,EACjC;AACD;;;AC1FA,SAAS,YAAY,0BAA0B,UAAU,QAAQ,cAAc;AAC/E,SAAS,+BAAAA,oCAAmC;AAyDrC,IAAM,iBAAiB,CAC7B,cAC2B;AAC3B,2BAAyB,cAAc;AAEvC,QAAM,UAAU,OAAO,CAAC;AACxB,QAAM,OAAOA,6BAA4B,WAAW,MAAM;AACzD,YAAQ,OAAO,CAAC,SAAS,OAAO,CAAC;AAAA,EAClC,CAAC;AAED,SAAO,UAAU,EAAE,UAAU,KAAK,IAAI;AAEtC,QAAM,UAAU,CAAC;AAEjB,aAAW,CAAC,KAAK,KAAK,KAAK,OAAO,QAAQ,UAAU,SAAS,CAAC,GAAG;AAChE,YAAQ,GAAG,IACV,OAAO,UAAU,aACd,QACA,SAAS,MAAM;AAIf,cAAQ;AAER,aAAQ,KAAK,KAAK,EAA8B,GAAG;AAAA,IACpD,CAAC;AAAA,EACL;AAEA,SAAO;AACR;;;ACvFA,SAAS,cAAAC,aAAY,4BAAAC,2BAA0B,UAAAC,SAAQ,UAAAC,eAAc;AACrE,SAAS,gCAAgC;AAiDlC,SAAS,WACf,WACA,UAC6B;AAC7B,EAAAF,0BAAyB,UAAU;AAEnC,QAAM,UAAU,yBAAyB,SAAS;AAClD,QAAM,OAAO,MACZ,WAAW,SAAS,UAAU,SAAS,CAAC,IAAI,QAAQ,KAAK;AAO1D,QAAM,QAAQE,QAA2B,KAAK,GAAG,EAAE,OAAO,MAAM,MAAM,CAAC;AAEvE,QAAM,OAAO,UAAU,UAAU,CAAC,MAAM,SAAS;AAChD,QAAI,UAAU;AACb,YAAM,SAAS,KAAK;AAKpB,UAAI,OAAO,GAAG,QAAQ,MAAM,CAAC,EAAG;AAEhC,YAAM,IAAI,MAAM;AAEhB;AAAA,IACD;AAEA,QAAI,CAAC,QAAQ,aAAa,MAAM,IAAI,GAAG;AAItC,cAAQ,cAAc,MAAM,IAAI;AAChC;AAAA,IACD;AAEA,UAAM,IAAI,KAAK,CAAC;AAAA,EACjB,CAAC;AACD,EAAAD,QAAOF,WAAU,EAAE,UAAU,IAAI;AAEjC,SAAO,MAAM,WAAW;AACzB;","names":["createLankaViewSubscription","DestroyRef","assertInInjectionContext","inject","signal"]}

package/dist/testing.d.ts

@@ -0,0 +1,46 @@
+import { RenderComponentOptions, RenderResult } from '@testing-library/angular';
+import { Type } from '@angular/core';
+import { IPrepareLankaRenderOptions } from '@lankajs/tool-testing';
+import { ILankaInstance } from 'lanka';
+
+interface IRenderWithLankaOptions<TComponent> extends Omit<RenderComponentOptions<TComponent>, "wrapper">, IPrepareLankaRenderOptions {
+}
+/**
+ * What a render with a bootstrapped framework ADDS to the library's own result.
+ *
+ * An interface over the addition rather than over the whole result, and the same
+ * in all five bindings: Svelte Testing Library's result carries a string index
+ * signature for its bound queries, so a named member added by extension has to
+ * satisfy it — and `lanka` is an instance, not a query. Describing only the
+ * addition is true of every library and needs no cast anywhere.
+ */
+interface IRenderWithLankaResult {
+    /** The instance the render used. */
+    lanka: ILankaInstance;
+}
+/**
+ * Rendering an Angular component with a bootstrapped framework.
+ *
+ * ## Why
+ *
+ * A component reading a ViewModel needs a live instance: without one the first
+ * scenario or locator access fails. Assembling bootstrap in every component test
+ * is twenty lines of preamble that diverge between files silently.
+ *
+ * ## What is here, and what is in the kit
+ *
+ * The five bindings publish this name and differ only in which `render` they
+ * call. Everything else — a fresh instance, the doubles, the caller's setup and
+ * the scenario layer brought up in that order — is `prepareLankaRender` in
+ * `@lankajs/tool-testing`, which is the one place all five already look.
+ *
+ * ## Angular's is asynchronous, and that is its own
+ *
+ * Angular Testing Library drives `TestBed`, which COMPILES a component rather
+ * than merely mounting one, so `render` answers a promise. The four other
+ * bindings answer directly. That difference belongs to Angular's testing story
+ * and not to lanka, which is why it is not hidden behind a synchronous wrapper.
+ */
+declare const renderWithLanka: <TComponent>(component: Type<TComponent>, options?: IRenderWithLankaOptions<TComponent>) => Promise<RenderResult<TComponent, TComponent> & IRenderWithLankaResult>;
+
+export { type IRenderWithLankaOptions, type IRenderWithLankaResult, renderWithLanka };