@zambon-dev/ui 0.0.0-stage → 0.0.1-bootstrap.0

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

@@ -0,0 +1,56 @@
+import * as i0 from '@angular/core';
+import { ViewContainerRef, ComponentRef, Type } 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.
+ */
+declare class InertHostComponent {
+    readonly outlet: i0.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. */
+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.
+ */
+declare function renderUnderOnPush<TComponent>(type: Type<TComponent>, inputs?: Record<string, unknown>): OnPushRender<TComponent>;
+
+export { InertHostComponent, renderUnderOnPush };
+export type { OnPushRender };

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';