@zambon-dev/ui 0.0.0-stage → 1.0.0

package/types/zambon-dev-ui-testing.d.ts

@@ -0,0 +1,51 @@
+import * as i0 from "@angular/core";
+import { ComponentRef, Type, ViewContainerRef } from "@angular/core";
+import { ComponentFixture } from "@angular/core/testing";
+/**
+ * A host that behaves exactly like a consumer application's own component: it declares no
+ * change-detection strategy, which in Angular 22 means `OnPush`. Once it has rendered it goes
+ * clean, and a top-down pass skips it -- `detectChangesInView` only refreshes a view in Global
+ * mode when it is `CheckAlways`, which an `OnPush` view never is, and then descends in Targeted
+ * mode where nothing below is reached either unless the path was marked.
+ *
+ * That is what makes it an oracle. A component that mutates state without telling Angular
+ * cannot update its DOM underneath this host, which is precisely the failure that a plain
+ * `TestBed.createComponent` + `fixture.detectChanges()` cannot express.
+ */
+export declare class InertHostComponent {
+  readonly outlet: import("@angular/core").Signal<ViewContainerRef>;
+  static ɵfac: i0.ɵɵFactoryDeclaration<InertHostComponent, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<InertHostComponent, "lib-inert-host", never, {}, {}, never, never, true, never>;
+}
+/** A component rendered beneath {@link InertHostComponent}, plus the handles a spec needs. */
+export interface OnPushRender<TComponent> {
+  /** The component under test. */
+  readonly component: TComponent;
+  readonly componentRef: ComponentRef<TComponent>;
+  /** The component under test's own host element -- host bindings included. */
+  readonly element: HTMLElement;
+  /** The fixture whose root is the inert host. */
+  readonly fixture: ComponentFixture<InertHostComponent>;
+  /** Binds an input the way a template would, notifying Angular. */
+  setInput(name: string, value: unknown): void;
+  /**
+   * Runs a change-detection pass that a clean `OnPush` ancestor can still short-circuit.
+   *
+   * Call this and never `fixture.detectChanges()` yourself -- under a zoneless test environment
+   * that call forces every test view and hands the component a refresh it did not earn.
+   */
+  tick(): void;
+}
+/**
+ * Renders `type` beneath a clean `OnPush` ancestor and returns once it has painted for the
+ * first time.
+ *
+ * Three rules make this an oracle rather than decoration:
+ *
+ * 1. Drive the source **after** this call returns. Before the first paint every strategy renders.
+ * 2. The source must be genuinely asynchronous. `of(...)` emits inside `ngOnInit`, i.e. inside
+ *    the first paint, so the failure cannot occur. Use a `Subject` you control.
+ * 3. Assert the DOM, never a field. `expect(component.loading).toBe(false)` passes on a blank
+ *    screen.
+ */
+export declare function renderUnderOnPush<TComponent>(type: Type<TComponent>, inputs?: Record<string, unknown>): OnPushRender<TComponent>;

package/types/zambon-dev-ui.d.ts

@@ -0,0 +1,3 @@
+export * from "@zambon-dev/ui/library";
+export * from "@zambon-dev/ui/framework";
+export * from "@zambon-dev/ui/shared";