@rivinia/modal 0.0.0-stage → 0.2.0

package/README.md

@@ -1,3 +1,81 @@
-# Temporary Holding Version
+# @rivinia/modal
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+[![npm version](https://img.shields.io/npm/v/@rivinia/modal.svg)](https://www.npmjs.com/package/@rivinia/modal)
+[![license](https://img.shields.io/npm/l/@rivinia/modal.svg)](https://www.npmjs.com/package/@rivinia/modal)
+
+Headless modal manager for Angular 22+. Stack/Queue strategies, typed
+`Promise` results, dismissal policies, async guards, ownership — zero DOM,
+zero styles, zero router dependency. A future `@rivinia/modal/ui` entry point
+will render this state; Core never imports UI.
+
+- Version: **0.2.0**
+- Requires: **Angular `^22.0.0`**, `tslib`
+
+## Install
+
+```bash
+npm install @rivinia/modal
+ng add @rivinia/modal   # wires provideRiviniaModal() into app.config.ts
+```
+
+```ts
+// app.config.ts
+import { provideRiviniaModal } from '@rivinia/modal';
+
+providers: [provideRiviniaModal({ strategy: 'stack', maxVisible: 3 })];
+```
+
+## Quick start
+
+```ts
+export class Users {
+  private modals = injectRiviniaModal();
+
+  async remove(user: User) {
+    const handle = this.modals.openModal<DeleteData, boolean>(confirmTemplate, {
+      data: { name: user.name },
+      ref: 'confirm-delete',
+    });
+    const result = await handle.result;
+    if (result.status === 'confirmed' && result.value) {
+      this.delete(user);
+    }
+    // 'cancelled' | 'dismissed' | 'queued-cancelled' | 'owner-destroyed' | 'rejected'
+  }
+}
+```
+
+## API
+
+| Export | Kind | Purpose |
+|---|---|---|
+| `provideRiviniaModal(config?)` | provider | `{ strategy?, dismiss?, maxVisible?, maxQueue?, overflow?, descendants?, presets?, closingTimeout?, diagnostics? }` |
+| `RiviniaModal` | `@Service()` | `openModal/close/dismiss/cancel/requestDismiss/update/confirmClosed/dismissAll/findByRef/useStrategy/debugState` + `active/queued/top` signals |
+| `injectRiviniaModal()` | function | shorthand for `inject(RiviniaModal)` |
+| `RIVINIA_MODAL_CONTEXT` | token | per-instance context for dynamic components |
+| `StackStrategy` / `QueueStrategy` | classes | built-in ordering policies (`ModalStrategy` for custom) |
+| types | types | `ModalHandle`, `ModalResult`, `ModalContent`, `ModalOpenOptions`, `ModalDismissPolicy`, `ModalGuard`, … |
+
+Results settle exactly once, at dismissal initiation — exit animations never
+delay callers. `close/dismiss/cancel` are guard-free primitives (booleans);
+`requestDismiss(id, origin)` runs async guards for user intents. Forced paths
+(owner destroy, overflow eviction, `dismissAll`) bypass guards. Render failures
+reject the promise instead of becoming variants.
+
+## Ownership (who cleans up)
+
+```ts
+// Owned by a short-lived component: dies with it (active → owner-destroyed)
+this.modals.openModal(tpl, { owner: this.destroyRef });
+
+// Independent (default): lives until closed — for services and app flows
+this.modals.openModal(tpl);
+```
+
+Closing a parent cascades to descendants (`dismissed: parent-closed`) unless
+`descendants: 'prevent-parent-close'` blocks it. Swapping strategies with live
+modals throws — close everything first.
+
+## License
+
+MIT.

package/fesm2022/rivinia-modal.mjs

@@ -0,0 +1,420 @@
+import * as i0 from "@angular/core";
+import { DestroyRef, InjectionToken, Service, computed, inject, makeEnvironmentProviders, signal } from "@angular/core";
+var StackStrategy = class {
+	name = "stack";
+	maxActive(maxVisible) {
+		return Math.max(1, Math.floor(maxVisible));
+	}
+	admit(visibleCount, _queuedCount, maxVisible) {
+		return visibleCount < Math.max(1, Math.floor(maxVisible)) ? "activate" : "queue";
+	}
+	order(visible) {
+		return [...visible].sort((a, b) => a.openedSeq - b.openedSeq);
+	}
+};
+var QueueStrategy = class {
+	name = "queue";
+	maxActive(_maxVisible) {
+		return 1;
+	}
+	admit(visibleCount, _queuedCount, _maxVisible) {
+		return visibleCount < 1 ? "activate" : "queue";
+	}
+	order(visible) {
+		return [...visible].sort((a, b) => a.openedSeq - b.openedSeq);
+	}
+};
+const RIVINIA_MODAL_CONTEXT = new InjectionToken("RIVINIA_MODAL_CONTEXT");
+const RIVINIA_MODAL_CONFIG = new InjectionToken("RIVINIA_MODAL_CONFIG");
+var RiviniaModal = class RiviniaModal {
+	config = inject(RIVINIA_MODAL_CONFIG, { optional: true });
+	_instances = signal([], ...ngDevMode ? [{ debugName: "_instances" }] : /* istanbul ignore next */ []);
+	_results = /* @__PURE__ */ new Map();
+	_strategy = this.resolveStrategy(this.config?.strategy);
+	_seq = 0;
+	_diagSeq = 0;
+	_diagnostics = [];
+	active = computed(() => this._strategy.order(this._instances().filter((i) => i.status === "active")), ...ngDevMode ? [{ debugName: "active" }] : /* istanbul ignore next */ []);
+	queued = computed(() => this._instances().filter((i) => i.status === "queued"), ...ngDevMode ? [{ debugName: "queued" }] : /* istanbul ignore next */ []);
+	top = computed(() => {
+		const list = this.active();
+		return list.length > 0 ? list[list.length - 1] : null;
+	}, ...ngDevMode ? [{ debugName: "top" }] : /* istanbul ignore next */ []);
+	constructor() {
+		inject(DestroyRef).onDestroy(() => {
+			for (const record of [...this._instances()]) if (record.status === "queued") {
+				this.remove(record.id);
+				this.settle(record.id, { status: "queued-cancelled" });
+			} else if (record.status !== "closed") {
+				this.clearClosingTimer(record);
+				this.remove(record.id);
+				this.settle(record.id, {
+					status: "dismissed",
+					reason: "manager-destroyed"
+				});
+			}
+		});
+	}
+	openModal(content, options = {}) {
+		const id = `modal-${++this._seq}`;
+		const pending = this.deferred();
+		this._results.set(id, pending);
+		const handle = {
+			id,
+			result: pending.promise,
+			close: (value) => this.close(id, value),
+			dismiss: (reason) => this.dismiss(id, reason),
+			cancel: (reason) => this.cancel(id, reason)
+		};
+		const visibleCount = this._instances().filter((i) => i.status !== "queued").length;
+		const intent = this._strategy.admit(visibleCount, this.queuedCount(), this.maxVisible());
+		let status = intent === "activate" ? "active" : "queued";
+		if (intent === "queue") {
+			const outcome = this.admitQueued(id);
+			if (outcome === "active" || outcome === "queued") status = outcome;
+			else {
+				this.settle(id, {
+					status: "rejected",
+					reason: outcome
+				});
+				this.diagnose("rejected", id, options.ref ?? null, outcome);
+				return handle;
+			}
+		}
+		const record = {
+			id,
+			ref: options.ref ?? null,
+			caller: options.caller ?? null,
+			parentId: this.knownParent(options.parentId) ? options.parentId : null,
+			data: options.data,
+			content,
+			status,
+			dismiss: {
+				closeOnEscape: true,
+				backdrop: "close",
+				...this.presetDismiss(options.preset),
+				...options.dismiss
+			},
+			metadata: { ...options.metadata ?? {} },
+			openedSeq: this._seq,
+			generation: 0,
+			guards: [...options.guards ?? []],
+			closingTimer: null,
+			ownerCleanup: null
+		};
+		if (options.parentId !== void 0 && record.parentId === null) this.diagnose("rejected", id, record.ref, "stale-parent");
+		this._instances.update((list) => [...list, record]);
+		if (options.owner) {
+			const off = options.owner.onDestroy(() => this.teardownOwned(id));
+			this.patch(id, { ownerCleanup: off });
+		}
+		this.diagnose(intent === "activate" ? "activated" : "queued", id, record.ref);
+		return handle;
+	}
+	close(id, value) {
+		const record = this.get(id);
+		if (!record || record.status !== "active" || this.blockedByDescendants(id)) return false;
+		this.beginClosing(id, "confirmed", void 0, value);
+		return true;
+	}
+	dismiss(id, reason) {
+		const record = this.get(id);
+		if (!record || this.blockedByDescendants(id)) return false;
+		if (record.status === "active") {
+			this.beginClosing(id, "dismissed", reason);
+			return true;
+		}
+		if (record.status === "queued") {
+			this.closeDescendants(id, true);
+			this.remove(id);
+			this.settle(id, {
+				status: "dismissed",
+				reason
+			});
+			this.diagnose("dismissed", id, record.ref, reason);
+			return true;
+		}
+		return false;
+	}
+	cancel(id, reason) {
+		const record = this.get(id);
+		if (!record || this.blockedByDescendants(id)) return false;
+		if (record.status === "queued") {
+			this.closeDescendants(id, true);
+			this.remove(id);
+			this.settle(id, { status: "queued-cancelled" });
+			this.diagnose("dismissed", id, record.ref, reason ?? "cancelled");
+			return true;
+		}
+		if (record.status !== "active") return false;
+		this.beginClosing(id, "cancelled", reason);
+		return true;
+	}
+	async requestDismiss(id, origin, reason) {
+		const record = this.get(id);
+		if (!record || record.status !== "active" || this.blockedByDescendants(id)) return false;
+		const generation = record.generation;
+		for (const guard of record.guards) {
+			let allowed;
+			try {
+				allowed = await guard({
+					id,
+					origin
+				});
+			} catch {
+				allowed = false;
+			}
+			const current = this.get(id);
+			if (!current || current.status !== "active" || current.generation !== generation) return false;
+			if (!allowed) {
+				this.diagnose("guard-denied", id, record.ref, origin);
+				return false;
+			}
+		}
+		return this.dismiss(id, reason ?? origin);
+	}
+	update(id, changes) {
+		const record = this.get(id);
+		if (!record || record.status !== "active" && record.status !== "queued") return false;
+		this._instances.update((list) => list.map((t) => t.id === id ? {
+			...t,
+			data: changes.data !== void 0 ? changes.data : t.data,
+			metadata: changes.metadata !== void 0 ? { ...changes.metadata } : t.metadata
+		} : t));
+		return true;
+	}
+	confirmClosed(id) {
+		const record = this.get(id);
+		if (!record || record.status !== "closing") return false;
+		this.finalize(id);
+		return true;
+	}
+	dismissAll(reason = "dismiss-all") {
+		for (const record of [...this._instances()]) if (record.status === "queued") {
+			this.remove(record.id);
+			this.settle(record.id, { status: "queued-cancelled" });
+		} else if (record.status === "active") this.beginClosing(record.id, "dismissed", reason);
+		else if (record.status === "closing") this.finalize(record.id);
+	}
+	findByRef(ref) {
+		return this._instances().filter((i) => i.ref === ref && i.status !== "closed");
+	}
+	useStrategy(strategy) {
+		if (this._instances().some((i) => i.status !== "closed")) throw new Error("[rivinia/modal] useStrategy() rejected: active, queued or closing modals exist. Close everything first — live migration is not supported.");
+		this._strategy = strategy;
+	}
+	debugState() {
+		const all = this._instances();
+		return {
+			strategy: this._strategy.name,
+			active: this.orderedActive().filter((i) => i.status === "active").map((i) => i.id),
+			closing: all.filter((i) => i.status === "closing").map((i) => i.id),
+			queued: all.filter((i) => i.status === "queued").map((i) => i.id)
+		};
+	}
+	getDiagnostics() {
+		return [...this._diagnostics];
+	}
+	clearDiagnostics() {
+		this._diagnostics.length = 0;
+	}
+	get(id) {
+		return this._instances().find((i) => i.id === id);
+	}
+	queuedCount() {
+		return this._instances().filter((i) => i.status === "queued").length;
+	}
+	orderedActive() {
+		return [...this._strategy.order(this._instances().filter((i) => i.status === "active" || i.status === "closing"))];
+	}
+	maxVisible() {
+		return Math.max(1, Math.floor(this.config?.maxVisible ?? 5));
+	}
+	maxQueue() {
+		const value = this.config?.maxQueue ?? Number.POSITIVE_INFINITY;
+		return value < 0 ? 0 : value;
+	}
+	presetDismiss(preset) {
+		if (!preset) return {};
+		return { ...this.config?.presets?.[preset]?.dismiss ?? {} };
+	}
+	knownParent(parentId) {
+		if (parentId === void 0) return false;
+		return this._instances().some((i) => i.id === parentId && i.status !== "closed");
+	}
+	admitQueued(id) {
+		switch (this.config?.overflow ?? "queue") {
+			case "reject": return "overflow";
+			case "dismiss-oldest": {
+				const oldest = this.orderedActive().find((i) => i.status === "active");
+				if (oldest) this.beginClosing(oldest.id, "dismissed", "overflow-evicted");
+				return "active";
+			}
+			default: return this.queuedCount() >= this.maxQueue() ? "queue-full" : "queued";
+		}
+	}
+	blockedByDescendants(id) {
+		if ((this.config?.descendants ?? "close-with-parent") !== "prevent-parent-close") return false;
+		const blocked = this._instances().some((i) => i.parentId === id && i.status !== "closed" && i.status !== "closing");
+		if (blocked) this.diagnose("strategy-rejected", id, this.get(id)?.ref ?? null, "prevent-parent-close");
+		return blocked;
+	}
+	beginClosing(id, status, reason, value) {
+		const record = this.get(id);
+		if (!record || record.status !== "active") return;
+		record.generation++;
+		this.closeDescendants(id, false);
+		this.patch(id, { status: "closing" });
+		if (status === "confirmed") this.settle(id, {
+			status,
+			value
+		});
+		else this.settle(id, {
+			status,
+			reason
+		});
+		this.diagnose("closing", id, record.ref, reason);
+		const timeout = Math.max(0, this.config?.closingTimeout ?? 300);
+		if (timeout === 0) return;
+		const generation = record.generation;
+		record.closingTimer = setTimeout(() => {
+			const current = this.get(id);
+			if (current && current.status === "closing" && current.generation === generation) this.finalize(id);
+		}, timeout);
+		this.patch(id, { closingTimer: record.closingTimer });
+	}
+	closeDescendants(parentId, force) {
+		if (!force && (this.config?.descendants ?? "close-with-parent") !== "close-with-parent") return;
+		for (const child of this._instances().filter((i) => i.parentId === parentId && (i.status === "active" || i.status === "queued"))) if (child.status === "queued") {
+			this.remove(child.id);
+			this.settle(child.id, { status: "queued-cancelled" });
+			this.diagnose("dismissed", child.id, child.ref, "parent-closed");
+		} else {
+			this.closeDescendants(child.id, force);
+			this.beginClosing(child.id, "dismissed", "parent-closed");
+		}
+	}
+	finalize(id, promoteAfter = true) {
+		const record = this.get(id);
+		if (!record) return;
+		this.clearClosingTimer(record);
+		this.patch(id, { status: "closed" });
+		record.ownerCleanup?.();
+		this._instances.update((list) => list.filter((i) => i.id !== id));
+		this._results.delete(id);
+		this.diagnose("closed", id, record.ref);
+		if (promoteAfter) this.promote();
+	}
+	promote() {
+		const width = this._strategy.maxActive(this.maxVisible());
+		const visible = () => this._instances().filter((i) => i.status === "active" || i.status === "closing").length;
+		while (visible() < width) {
+			const head = this._instances().find((i) => i.status === "queued");
+			if (!head) break;
+			this.patch(head.id, { status: "active" });
+			this.diagnose("promoted", head.id, head.ref);
+		}
+	}
+	remove(id) {
+		const record = this.get(id);
+		if (record) this.clearClosingTimer(record);
+		this._instances.update((list) => list.filter((i) => i.id !== id));
+	}
+	clearClosingTimer(record) {
+		if (record.closingTimer) {
+			clearTimeout(record.closingTimer);
+			record.closingTimer = null;
+		}
+	}
+	teardownOwned(id) {
+		const record = this.get(id);
+		if (!record || record.status === "closed" || record.status === "closing") return;
+		if (record.status === "queued") {
+			this.closeDescendants(id, true);
+			this.remove(id);
+			this.settle(id, { status: "queued-cancelled" });
+			this.diagnose("dismissed", id, record.ref, "owner-destroyed");
+			return;
+		}
+		record.generation++;
+		this.closeDescendants(id, true);
+		this.patch(id, { status: "closing" });
+		this.settle(id, { status: "owner-destroyed" });
+		this.diagnose("closing", id, record.ref, "owner-destroyed");
+		this.finalize(id, false);
+	}
+	patch(id, changes) {
+		this._instances.update((list) => list.map((t) => t.id === id ? {
+			...t,
+			...changes
+		} : t));
+	}
+	deferred() {
+		let resolve;
+		return {
+			promise: new Promise((res) => {
+				resolve = res;
+			}),
+			resolve: (value) => {
+				resolve(value);
+			},
+			settled: false
+		};
+	}
+	settle(id, value) {
+		const pending = this._results.get(id);
+		if (!pending || pending.settled) return;
+		pending.settled = true;
+		pending.resolve(value);
+	}
+	diagnose(type, id, ref, reason) {
+		if (!this.config?.diagnostics) return;
+		this._diagnostics.push({
+			seq: ++this._diagSeq,
+			type,
+			id,
+			ref,
+			reason
+		});
+		while (this._diagnostics.length > 100) this._diagnostics.shift();
+	}
+	resolveStrategy(configured) {
+		if (!configured || configured === "stack") return new StackStrategy();
+		if (configured === "queue") return new QueueStrategy();
+		return configured;
+	}
+	static ɵfac = i0.ɵɵngDeclareFactory({
+		minVersion: "12.0.0",
+		version: "22.2.2",
+		ngImport: i0,
+		type: RiviniaModal,
+		deps: [],
+		target: i0.ɵɵFactoryTarget.Service
+	});
+	static ɵprov = i0.ɵɵngDeclareService({
+		minVersion: "22.0.0",
+		version: "22.2.2",
+		ngImport: i0,
+		type: RiviniaModal
+	});
+};
+i0.ɵɵngDeclareClassMetadata({
+	minVersion: "12.0.0",
+	version: "22.2.2",
+	ngImport: i0,
+	type: RiviniaModal,
+	decorators: [{ type: Service }],
+	ctorParameters: () => []
+});
+function provideRiviniaModal(config = {}) {
+	return makeEnvironmentProviders([{
+		provide: RIVINIA_MODAL_CONFIG,
+		useValue: config
+	}]);
+}
+function injectRiviniaModal() {
+	return inject(RiviniaModal);
+}
+export { QueueStrategy, RIVINIA_MODAL_CONTEXT, RiviniaModal, StackStrategy, injectRiviniaModal, provideRiviniaModal };
+
+//# sourceMappingURL=rivinia-modal.mjs.map

package/fesm2022/rivinia-modal.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"rivinia-modal.mjs","names":[],"sources":["../../../projects/modal/src/lib/modal-strategy.ts","../../../projects/modal/src/lib/modal-context.ts","../../../projects/modal/src/lib/modal-config.ts","../../../projects/modal/src/lib/rivinia-modal.ts","../../../projects/modal/src/lib/provide-modal.ts"],"sourcesContent":["/**\n * Ordering/admission policy. Strategies are pure with respect to lifecycle:\n * the manager owns identity, results, timers and disposal; strategies own\n * ordering and activation width. No mode-dependent `if/else` in the manager.\n */\nexport interface ModalStrategy {\n  readonly name: string;\n  /** Maximum simultaneously active instances under this strategy. */\n  maxActive(maxVisible: number): number;\n  /**\n   * Admission of a new request given current visible/queued sets.\n   * Returns the action; the manager executes it (and settles results).\n   */\n  admit(visibleCount: number, queuedCount: number, maxVisible: number): 'activate' | 'queue';\n  /** Display order of visible instances, bottom-first. */\n  order<T extends { readonly openedSeq: number }>(visible: readonly T[]): readonly T[];\n}\n\n/** Multiple concurrent modals, topmost (last opened) interactive. */\nexport class StackStrategy implements ModalStrategy {\n  readonly name = 'stack';\n  maxActive(maxVisible: number): number {\n    return Math.max(1, Math.floor(maxVisible));\n  }\n  admit(visibleCount: number, _queuedCount: number, maxVisible: number): 'activate' | 'queue' {\n    return visibleCount < Math.max(1, Math.floor(maxVisible)) ? 'activate' : 'queue';\n  }\n  order<T extends { readonly openedSeq: number }>(visible: readonly T[]): readonly T[] {\n    return [...visible].sort((a, b) => a.openedSeq - b.openedSeq);\n  }\n}\n\n/** Strictly serial: one active modal, FIFO activation of the rest. */\nexport class QueueStrategy implements ModalStrategy {\n  readonly name = 'queue';\n  maxActive(_maxVisible: number): number {\n    return 1;\n  }\n  admit(visibleCount: number, _queuedCount: number, _maxVisible: number): 'activate' | 'queue' {\n    return visibleCount < 1 ? 'activate' : 'queue';\n  }\n  order<T extends { readonly openedSeq: number }>(visible: readonly T[]): readonly T[] {\n    return [...visible].sort((a, b) => a.openedSeq - b.openedSeq);\n  }\n}\n","import { InjectionToken } from '@angular/core';\nimport type { ModalContext } from './modal-types';\n\n/**\n * Injection token providing the `ModalContext` of the enclosing modal to\n * dynamically created components. Template content receives the same object\n * as `let-modal=\"modal\"`. Never global — one value per modal instance.\n */\nexport const RIVINIA_MODAL_CONTEXT = new InjectionToken<ModalContext<unknown>>(\n  'RIVINIA_MODAL_CONTEXT',\n);\n","import { InjectionToken } from '@angular/core';\nimport type {\n  DescendantPolicy,\n  ModalDismissPolicy,\n  ModalOverflowPolicy,\n} from './modal-types';\n\n/** Named preset: a reusable dismissal shape (explicit options always win). */\nexport interface ModalPreset {\n  readonly dismiss?: Partial<ModalDismissPolicy>;\n}\n\n/**\n * Global configuration for `@rivinia/modal`. Everything optional; per-open\n * options win. No styling, positions, icons, or translations here — ever.\n */\nexport interface RiviniaModalConfig {\n  /**\n   * Ordering/activation policy. `'stack'` = up to `maxVisible` concurrent,\n   * topmost interactive. `'queue'` = strictly serial (one active, FIFO rest).\n   * A custom `ModalStrategy` instance is also accepted.\n   * @default 'stack'\n   */\n  readonly strategy?: 'stack' | 'queue' | import('./modal-strategy').ModalStrategy;\n  /** Global dismissal defaults. @default { closeOnEscape: true, backdrop: 'close' } */\n  readonly dismiss?: ModalDismissPolicy;\n  /** Capacity of simultaneously active modals. Clamped to ≥ 1. @default 5 */\n  readonly maxVisible?: number;\n  /** Bound for queued requests (queue policy). @default Infinity */\n  readonly maxQueue?: number;\n  /** Overflow behavior when full. @default 'queue' (lossless — never drops input) */\n  readonly overflow?: ModalOverflowPolicy;\n  /** Parent closure with remaining descendants. @default 'close-with-parent' */\n  readonly descendants?: DescendantPolicy;\n  /** Named dismissal presets referenced by `openModal({ preset })`. */\n  readonly presets?: Record<string, ModalPreset>;\n  /**\n   * Time the manager waits for UI teardown confirmation (`confirmClosed`)\n   * before auto-finalizing a `closing` instance. `0` = manual only.\n   * @default 300\n   */\n  readonly closingTimeout?: number;\n  /**\n   * Bounded transition log for debugging (ring buffer, no payloads).\n   * Off by default to stay production-light.\n   * @default false\n   */\n  readonly diagnostics?: boolean;\n}\n\n/**\n * Internal configuration token. Consumers must use `provideRiviniaModal()`.\n * @internal\n */\nexport const RIVINIA_MODAL_CONFIG = new InjectionToken<RiviniaModalConfig>(\n  'RIVINIA_MODAL_CONFIG',\n);\n\nexport const DEFAULT_MAX_VISIBLE = 5;\nexport const DEFAULT_CLOSING_TIMEOUT = 300;\nexport const DIAGNOSTIC_CAP = 100;\n","import { DestroyRef, computed, inject, Service, signal } from '@angular/core';\nimport {\n  DEFAULT_CLOSING_TIMEOUT,\n  DEFAULT_MAX_VISIBLE,\n  DIAGNOSTIC_CAP,\n  RIVINIA_MODAL_CONFIG,\n  type RiviniaModalConfig,\n} from './modal-config';\nimport type {\n  ModalDiagnostic,\n  ModalDismissOrigin,\n  ModalGuard,\n  ModalHandle,\n  ModalInstance,\n  ModalOpenOptions,\n  ModalResult,\n  ModalUpdate,\n} from './modal-types';\nimport { QueueStrategy, StackStrategy, type ModalStrategy } from './modal-strategy';\n\ninterface ModalRecord extends ModalInstance<unknown> {\n  openedSeq: number;\n  generation: number;\n  guards: readonly ModalGuard[];\n  closingTimer: ReturnType<typeof setTimeout> | null;\n  ownerCleanup: (() => void) | null;\n}\n\ninterface PendingResult {\n  promise: Promise<ModalResult<unknown>>;\n  resolve: (value: ModalResult<unknown>) => void;\n  settled: boolean;\n}\n\n/**\n * Headless modal manager. Owns identity, lifecycle coordination, result\n * settlement and diagnostics. Ordering/admission policy is delegated to a\n * `ModalStrategy` (Stack/Queue/custom) — the manager never branches on mode.\n *\n * Settlement contract (each path settles exactly once, never hangs):\n * - `close()` on active → `confirmed` · `dismiss()` on active → `dismissed`\n * - `cancel()` on active → `cancelled` · on queued → `queued-cancelled`\n * - `dismiss()` on queued → `dismissed` with the reason (pre-activation)\n * - overflow/guard refusal → `rejected` · owner gone → `owner-destroyed`\n * - forced paths (owner, overflow eviction, `dismissAll`) bypass guards\n * - `close/dismiss/cancel` are guard-free primitives; `requestDismiss` runs\n *   guards for user intents (escape/backdrop/button) or explicit review\n * - infrastructure failures reject the promise — never a result variant\n *\n * Results settle at dismissal initiation, not after UI teardown: animations\n * never delay callers. The `closing` → `closed` handshake (`confirmClosed`\n * or `closingTimeout` auto-finalize) exists only for exit animations.\n */\n@Service()\nexport class RiviniaModal {\n  private readonly config = inject<RiviniaModalConfig>(RIVINIA_MODAL_CONFIG, {\n    optional: true,\n  });\n\n  private readonly _instances = signal<readonly ModalRecord[]>([]);\n  private readonly _results = new Map<string, PendingResult>();\n  private _strategy: ModalStrategy = this.resolveStrategy(this.config?.strategy);\n  private _seq = 0;\n  private _diagSeq = 0;\n  private readonly _diagnostics: ModalDiagnostic[] = [];\n\n  /** Active instances in strategy display order (bottom-first). */\n  readonly active = computed<readonly ModalInstance[]>(() =>\n    this._strategy.order(this._instances().filter((i) => i.status === 'active')),\n  );\n  /** Queued instances, FIFO admission order. */\n  readonly queued = computed<readonly ModalInstance[]>(() =>\n    this._instances().filter((i) => i.status === 'queued'),\n  );\n  /** Topmost active instance (the only Escape-eligible one), if any. */\n  readonly top = computed<ModalInstance | null>(() => {\n    const list = this.active();\n    return list.length > 0 ? list[list.length - 1] : null;\n  });\n\n  constructor() {\n    inject(DestroyRef).onDestroy(() => {\n      for (const record of [...this._instances()]) {\n        if (record.status === 'queued') {\n          this.remove(record.id);\n          this.settle(record.id, { status: 'queued-cancelled' });\n        } else if (record.status !== 'closed') {\n          this.clearClosingTimer(record);\n          this.remove(record.id);\n          this.settle(record.id, { status: 'dismissed', reason: 'manager-destroyed' });\n        }\n      }\n    });\n  }\n\n  openModal<TData = unknown, TResult = unknown>(\n    content: import('./modal-types').ModalContent<TData>,\n    options: ModalOpenOptions<TData> = {},\n  ): ModalHandle<TResult> {\n    const id = `modal-${++this._seq}`;\n    const pending = this.deferred();\n    this._results.set(id, pending);\n    const handle: ModalHandle<TResult> = {\n      id,\n      result: pending.promise as Promise<ModalResult<TResult>>,\n      close: (value?: TResult) => this.close(id, value),\n      dismiss: (reason?: string) => this.dismiss(id, reason),\n      cancel: (reason?: string) => this.cancel(id, reason),\n    };\n\n    const visibleCount = this._instances().filter((i) => i.status !== 'queued').length;\n    const intent = this._strategy.admit(visibleCount, this.queuedCount(), this.maxVisible());\n    let status: 'active' | 'queued' = intent === 'activate' ? 'active' : 'queued';\n    if (intent === 'queue') {\n      const outcome = this.admitQueued(id);\n      if (outcome === 'active' || outcome === 'queued') {\n        // 'dismiss-oldest' evicted room: the newcomer activates immediately.\n        // 'queue' keeps it queued.\n        status = outcome;\n      } else {\n        this.settle(id, { status: 'rejected', reason: outcome });\n        this.diagnose('rejected', id, options.ref ?? null, outcome);\n        return handle;\n      }\n    }\n\n    const record: ModalRecord = {\n      id,\n      ref: options.ref ?? null,\n      caller: options.caller ?? null,\n      parentId: this.knownParent(options.parentId) ? (options.parentId as string) : null,\n      data: options.data as unknown,\n      content: content as ModalRecord['content'],\n      status,\n      dismiss: {\n        closeOnEscape: true,\n        backdrop: 'close',\n        ...this.presetDismiss(options.preset),\n        ...options.dismiss,\n      },\n      metadata: { ...(options.metadata ?? {}) },\n      openedSeq: this._seq,\n      generation: 0,\n      guards: [...(options.guards ?? [])],\n      closingTimer: null,\n      ownerCleanup: null,\n    };\n    if (options.parentId !== undefined && record.parentId === null) {\n      this.diagnose('rejected', id, record.ref, 'stale-parent');\n    }\n    this._instances.update((list) => [...list, record]);\n\n    if (options.owner) {\n      const off = options.owner.onDestroy(() => this.teardownOwned(id));\n      this.patch(id, { ownerCleanup: off });\n    }\n    this.diagnose(intent === 'activate' ? 'activated' : 'queued', id, record.ref);\n    return handle;\n  }\n\n  /**\n   * Confirms with a value. Active instances only; settles `confirmed`.\n   * Blocked (returns `false`) by the prevent-parent-close policy.\n   */\n  close(id: string, value?: unknown): boolean {\n    const record = this.get(id);\n    if (!record || record.status !== 'active' || this.blockedByDescendants(id)) return false;\n    this.beginClosing(id, 'confirmed', undefined, value);\n    return true;\n  }\n\n  /**\n   * Guard-free dismissal primitive. Active → `dismissed`; queued → removed as\n   * `dismissed` with the reason. Blocked by prevent-parent-close.\n   */\n  dismiss(id: string, reason?: string): boolean {\n    const record = this.get(id);\n    if (!record || this.blockedByDescendants(id)) return false;\n    if (record.status === 'active') {\n      this.beginClosing(id, 'dismissed', reason);\n      return true;\n    }\n    if (record.status === 'queued') {\n      this.closeDescendants(id, true);\n      this.remove(id);\n      this.settle(id, { status: 'dismissed', reason });\n      this.diagnose('dismissed', id, record.ref, reason);\n      return true;\n    }\n    return false;\n  }\n\n  /**\n   * Cancels: active → `cancelled`, queued → removed as `queued-cancelled`.\n   * Blocked by prevent-parent-close. Closing/closed/unknown → `false`.\n   */\n  cancel(id: string, reason?: string): boolean {\n    const record = this.get(id);\n    if (!record || this.blockedByDescendants(id)) return false;\n    if (record.status === 'queued') {\n      this.closeDescendants(id, true);\n      this.remove(id);\n      this.settle(id, { status: 'queued-cancelled' });\n      this.diagnose('dismissed', id, record.ref, reason ?? 'cancelled');\n      return true;\n    }\n    if (record.status !== 'active') return false;\n    this.beginClosing(id, 'cancelled', reason);\n    return true;\n  }\n\n  /**\n   * Guarded dismissal for user intents (escape/backdrop/button) or explicit\n   * programmatic review. Guards run sequentially; any `false` or throw denies\n   * (stays open + diagnostic). Stale guard completions are ignored.\n   */\n  async requestDismiss(\n    id: string,\n    origin: ModalDismissOrigin,\n    reason?: string,\n  ): Promise<boolean> {\n    const record = this.get(id);\n    if (!record || record.status !== 'active' || this.blockedByDescendants(id)) return false;\n    const generation = record.generation;\n    for (const guard of record.guards) {\n      let allowed: boolean;\n      try {\n        allowed = await guard({ id, origin });\n      } catch {\n        allowed = false;\n      }\n      const current = this.get(id);\n      if (!current || current.status !== 'active' || current.generation !== generation) {\n        return false; // Resolved stale: something else already moved it.\n      }\n      if (!allowed) {\n        this.diagnose('guard-denied', id, record.ref, origin);\n        return false;\n      }\n    }\n    return this.dismiss(id, reason ?? origin);\n  }\n\n  /** Merges data/metadata (new object identity so UI re-renders). */\n  update<TData>(id: string, changes: import('./modal-types').ModalUpdate<TData>): boolean {\n    const record = this.get(id);\n    if (!record || (record.status !== 'active' && record.status !== 'queued')) return false;\n    this._instances.update((list) =>\n      list.map((t) =>\n        t.id === id\n          ? {\n              ...t,\n              data: (changes.data !== undefined ? changes.data : t.data) as unknown,\n              metadata: changes.metadata !== undefined ? { ...changes.metadata } : t.metadata,\n            }\n          : t,\n      ),\n    );\n    return true;\n  }\n\n  /** UI teardown confirmation after exit animations. Auto-finalizes via timeout. */\n  confirmClosed(id: string): boolean {\n    const record = this.get(id);\n    if (!record || record.status !== 'closing') return false;\n    this.finalize(id);\n    return true;\n  }\n\n  /** Forced cleanup (bypasses guards): active → `dismissed`, queued → `queued-cancelled`. */\n  dismissAll(reason = 'dismiss-all'): void {\n    for (const record of [...this._instances()]) {\n      if (record.status === 'queued') {\n        this.remove(record.id);\n        this.settle(record.id, { status: 'queued-cancelled' });\n      } else if (record.status === 'active') {\n        this.beginClosing(record.id, 'dismissed', reason);\n      } else if (record.status === 'closing') {\n        this.finalize(record.id);\n      }\n    }\n  }\n\n  /** Non-closed snapshots for a definition ref (e.g. avoid duplicate confirms). */\n  findByRef(ref: string): ModalInstance[] {\n    return this._instances().filter((i) => i.ref === ref && i.status !== 'closed');\n  }\n\n  /**\n   * Swaps the strategy. Rejected with an explicit error while any instance is\n   * not closed — silent live migration is never attempted.\n   */\n  useStrategy(strategy: ModalStrategy): void {\n    if (this._instances().some((i) => i.status !== 'closed')) {\n      throw new Error(\n        '[rivinia/modal] useStrategy() rejected: active, queued or closing modals exist. ' +\n          'Close everything first — live migration is not supported.',\n      );\n    }\n    this._strategy = strategy;\n  }\n\n  /** Introspection snapshot. Active means interactive; closing instances are\n   * still rendered (exit animations) until `confirmClosed`/timeout finalizes. */\n  debugState(): { strategy: string; active: string[]; closing: string[]; queued: string[] } {\n    const all = this._instances();\n    return {\n      strategy: this._strategy.name,\n      active: this.orderedActive()\n        .filter((i) => i.status === 'active')\n        .map((i) => i.id),\n      closing: all.filter((i) => i.status === 'closing').map((i) => i.id),\n      queued: all.filter((i) => i.status === 'queued').map((i) => i.id),\n    };\n  }\n\n  /** Bounded transition log (only when `diagnostics: true`). */\n  getDiagnostics(): readonly import('./modal-types').ModalDiagnostic[] {\n    return [...this._diagnostics];\n  }\n\n  clearDiagnostics(): void {\n    this._diagnostics.length = 0;\n  }\n\n  // ------------------------------------------------------------------ internals\n\n  private get(id: string): ModalRecord | undefined {\n    return this._instances().find((i) => i.id === id);\n  }\n\n  private queuedCount(): number {\n    return this._instances().filter((i) => i.status === 'queued').length;\n  }\n\n  private orderedActive(): ModalRecord[] {\n    return [\n      ...this._strategy.order(\n        this._instances().filter((i) => i.status === 'active' || i.status === 'closing'),\n      ),\n    ];\n  }\n\n  private maxVisible(): number {\n    return Math.max(1, Math.floor(this.config?.maxVisible ?? DEFAULT_MAX_VISIBLE));\n  }\n\n  private maxQueue(): number {\n    const value = this.config?.maxQueue ?? Number.POSITIVE_INFINITY;\n    return value < 0 ? 0 : value;\n  }\n\n  private presetDismiss(preset?: string): Record<string, unknown> {\n    if (!preset) return {};\n    return { ...(this.config?.presets?.[preset]?.dismiss ?? {}) };\n  }\n\n  private knownParent(parentId: string | undefined): parentId is string {\n    if (parentId === undefined) return false;\n    return this._instances().some((i) => i.id === parentId && i.status !== 'closed');\n  }\n\n  /** Overflow handling for queue-intent admissions. Returns rejection reason, or the resulting status. */\n  private admitQueued(id: string): string | 'active' | 'queued' {\n    switch (this.config?.overflow ?? 'queue') {\n      case 'reject':\n        return 'overflow';\n      case 'dismiss-oldest': {\n        // Preempt: evict oldest pure-active instance (system path, no guards).\n        const oldest = this.orderedActive().find((i) => i.status === 'active');\n        if (oldest) this.beginClosing(oldest.id, 'dismissed', 'overflow-evicted');\n        return 'active';\n      }\n      case 'queue':\n      default:\n        return this.queuedCount() >= this.maxQueue() ? 'queue-full' : 'queued';\n    }\n  }\n\n  private blockedByDescendants(id: string): boolean {\n    if ((this.config?.descendants ?? 'close-with-parent') !== 'prevent-parent-close') {\n      return false;\n    }\n    const blocked = this._instances().some(\n      (i) => i.parentId === id && i.status !== 'closed' && i.status !== 'closing',\n    );\n    if (blocked) this.diagnose('strategy-rejected', id, this.get(id)?.ref ?? null, 'prevent-parent-close');\n    return blocked;\n  }\n\n  private beginClosing(\n    id: string,\n    status: 'confirmed' | 'dismissed' | 'cancelled',\n    reason?: string,\n    value?: unknown,\n  ): void {\n    const record = this.get(id);\n    if (!record || record.status !== 'active') return;\n    record.generation++;\n    this.closeDescendants(id, false);\n    this.patch(id, { status: 'closing' });\n    if (status === 'confirmed') {\n      this.settle(id, { status, value } as ModalResult<unknown>);\n    } else {\n      this.settle(id, { status, reason } as ModalResult<unknown>);\n    }\n    this.diagnose('closing', id, record.ref, reason);\n    const timeout = Math.max(0, this.config?.closingTimeout ?? DEFAULT_CLOSING_TIMEOUT);\n    if (timeout === 0) return; // Manual teardown: UI must call confirmClosed().\n    const generation = record.generation;\n    record.closingTimer = setTimeout(() => {\n      const current = this.get(id);\n      if (current && current.status === 'closing' && current.generation === generation) {\n        this.finalize(id);\n      }\n    }, timeout);\n    // Patch the timer into the stored record (same object identity held above).\n    this.patch(id, { closingTimer: record.closingTimer });\n  }\n\n  private closeDescendants(parentId: string, force: boolean): void {\n    if (!force && (this.config?.descendants ?? 'close-with-parent') !== 'close-with-parent') {\n      return;\n    }\n    for (const child of this._instances().filter(\n      (i) => i.parentId === parentId && (i.status === 'active' || i.status === 'queued'),\n    )) {\n      if (child.status === 'queued') {\n        this.remove(child.id);\n        this.settle(child.id, { status: 'queued-cancelled' });\n        this.diagnose('dismissed', child.id, child.ref, 'parent-closed');\n      } else {\n        this.closeDescendants(child.id, force);\n        this.beginClosing(child.id, 'dismissed', 'parent-closed');\n      }\n    }\n  }\n\n  private finalize(id: string, promoteAfter = true): void {\n    const record = this.get(id);\n    if (!record) return;\n    this.clearClosingTimer(record);\n    this.patch(id, { status: 'closed' });\n    record.ownerCleanup?.();\n    this._instances.update((list) => list.filter((i) => i.id !== id));\n    this._results.delete(id);\n    this.diagnose('closed', id, record.ref);\n    if (promoteAfter) this.promote();\n  }\n\n  private promote(): void {\n    const width = this._strategy.maxActive(this.maxVisible());\n    const visible = (): number =>\n      this._instances().filter((i) => i.status === 'active' || i.status === 'closing').length;\n    while (visible() < width) {\n      const head = this._instances().find((i) => i.status === 'queued');\n      if (!head) break;\n      this.patch(head.id, { status: 'active' });\n      this.diagnose('promoted', head.id, head.ref);\n    }\n  }\n\n  private remove(id: string): void {\n    const record = this.get(id);\n    if (record) this.clearClosingTimer(record);\n    this._instances.update((list) => list.filter((i) => i.id !== id));\n  }\n\n  private clearClosingTimer(record: ModalRecord): void {\n    if (record.closingTimer) {\n      clearTimeout(record.closingTimer);\n      record.closingTimer = null;\n    }\n  }\n\n  private teardownOwned(id: string): void {\n    const record = this.get(id);\n    if (!record || record.status === 'closed' || record.status === 'closing') return;\n    if (record.status === 'queued') {\n      this.closeDescendants(id, true);\n      this.remove(id);\n      this.settle(id, { status: 'queued-cancelled' });\n      this.diagnose('dismissed', id, record.ref, 'owner-destroyed');\n      return;\n    }\n    record.generation++;\n    this.closeDescendants(id, true);\n    this.patch(id, { status: 'closing' });\n    this.settle(id, { status: 'owner-destroyed' });\n    this.diagnose('closing', id, record.ref, 'owner-destroyed');\n    // No promotion: tearing down must not activate queued requests\n    // only to destroy them a moment later (changes their settlement).\n    this.finalize(id, false);\n  }\n\n  private patch(id: string, changes: Partial<ModalRecord>): void {\n    this._instances.update((list) => list.map((t) => (t.id === id ? { ...t, ...changes } : t)));\n  }\n\n  private deferred<TResult>(): PendingResult & { promise: Promise<ModalResult<TResult>> } {\n    let resolve!: (value: ModalResult<unknown>) => void;\n    const promise = new Promise<ModalResult<unknown>>((res) => {\n      resolve = res;\n    });\n    return {\n      promise: promise as Promise<ModalResult<TResult>>,\n      resolve: (value) => {\n        resolve(value);\n      },\n      settled: false,\n    };\n  }\n\n  private settle(id: string, value: ModalResult<unknown>): void {\n    const pending = this._results.get(id);\n    if (!pending || pending.settled) return; // Exactly-once, even under reentrancy.\n    pending.settled = true;\n    pending.resolve(value);\n  }\n\n  private diagnose(\n    type: import('./modal-types').ModalDiagnostic['type'],\n    id: string,\n    ref: string | null,\n    reason?: string,\n  ): void {\n    if (!this.config?.diagnostics) return;\n    this._diagnostics.push({ seq: ++this._diagSeq, type, id, ref, reason });\n    while (this._diagnostics.length > DIAGNOSTIC_CAP) this._diagnostics.shift();\n  }\n\n  private resolveStrategy(configured: RiviniaModalConfig['strategy']): ModalStrategy {\n    if (!configured || configured === 'stack') return new StackStrategy();\n    if (configured === 'queue') return new QueueStrategy();\n    return configured;\n  }\n}\n","import { EnvironmentProviders, inject, makeEnvironmentProviders } from '@angular/core';\nimport { RIVINIA_MODAL_CONFIG, type RiviniaModalConfig } from './modal-config';\nimport { RiviniaModal } from './rivinia-modal';\n\n/**\n * Configures `@rivinia/modal`. The manager is a root singleton; call once at\n * bootstrap. Per-open options always win over these globals. No styling,\n * positions, or icons here — ever.\n *\n * @example\n * ```ts\n * provideRiviniaModal({ strategy: 'stack', maxVisible: 3 })\n * ```\n */\nexport function provideRiviniaModal(config: RiviniaModalConfig = {}): EnvironmentProviders {\n  return makeEnvironmentProviders([{ provide: RIVINIA_MODAL_CONFIG, useValue: config }]);\n}\n\n/** Shorthand for `inject(RiviniaModal)`. */\nexport function injectRiviniaModal(): RiviniaModal {\n  return inject(RiviniaModal);\n}\n"],"mappings":"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"}

package/package.json

@@ -1,6 +1,33 @@
 {
   "name": "@rivinia/modal",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
+  "version": "0.2.0",
+  "description": "Headless modal manager for Angular: stack/queue strategies, typed results, guards, ownership.",
+  "keywords": [
+    "angular",
+    "modal",
+    "dialog",
+    "signals",
+    "typescript"
+  ],
+  "license": "MIT",
+  "peerDependencies": {
+    "@angular/core": "^22.0.0"
+  },
+  "sideEffects": false,
+  "schematics": "./schematics/collection.json",
+  "module": "fesm2022/rivinia-modal.mjs",
+  "typings": "types/rivinia-modal.d.ts",
+  "exports": {
+    "./package.json": {
+      "default": "./package.json"
+    },
+    ".": {
+      "types": "./types/rivinia-modal.d.ts",
+      "default": "./fesm2022/rivinia-modal.mjs"
+    }
+  },
+  "type": "module",
+  "dependencies": {
+    "tslib": "^2.3.0"
+  }
 }

package/schematics/collection.json

@@ -0,0 +1,10 @@
+{
+  "$schema": "../../../node_modules/@angular-devkit/schematics/collection-schema.json",
+  "schematics": {
+    "ng-add": {
+      "description": "Add provideRiviniaModal() to the application config.",
+      "factory": "./ng-add/index.cjs#ngAdd",
+      "schema": "./ng-add/schema.json"
+    }
+  }
+}

package/schematics/ng-add/index.cjs

@@ -0,0 +1,101 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ngAdd = ngAdd;
+const schematics_1 = require("@angular-devkit/schematics");
+const PROVIDE_IMPORT = `import { provideRiviniaModal } from '@rivinia/modal';`;
+/**
+ * `ng add @rivinia/modal` — wires the manager into a standalone app config.
+ *
+ * - Never overwrites user files; only inserts one import + one provider.
+ * - Idempotent: safe to run twice. No prompts by design (strategy is a
+ *   one-line edit; pass `--strategy queue` or edit afterwards).
+ * - Rendering outlet (`<rv-modal-outlet/>` in a future `/ui` entry) is a
+ *   layout decision the schematic never makes for you.
+ */
+function ngAdd(options) {
+    return (tree, context) => {
+        let configPath;
+        try {
+            configPath = findAppConfig(tree, options.project);
+        }
+        catch (error) {
+            context.logger.warn(`[rivinia/modal] workspace lookup failed (${error instanceof Error ? error.message : error}) — skipping. ` +
+                `Add provideRiviniaModal() manually (see README).`);
+            return tree;
+        }
+        if (!configPath || !tree.exists(configPath)) {
+            context.logger.warn(`[rivinia/modal] app.config.ts not found — skipping. ` +
+                `Add provideRiviniaModal() manually (see README).`);
+            return tree;
+        }
+        let content = tree.read(configPath)?.toString('utf-8') ?? '';
+        if (!content) {
+            throw new schematics_1.SchematicsException(`[rivinia/modal] ${configPath} is empty.`);
+        }
+        const provideCall = options.strategy !== undefined ? `provideRiviniaModal({ strategy: '${options.strategy}' })` : 'provideRiviniaModal()';
+        let changed = false;
+        if (!content.includes(PROVIDE_IMPORT)) {
+            content = insertAfterLastImport(content, PROVIDE_IMPORT);
+            changed = true;
+        }
+        if (!content.includes('provideRiviniaModal(')) {
+            content = insertProvider(content, provideCall);
+            changed = true;
+        }
+        else {
+            context.logger.info('[rivinia/modal] provideRiviniaModal() already present — skipped.');
+        }
+        if (changed) {
+            tree.overwrite(configPath, content);
+            context.logger.info(`[rivinia/modal] wired into ${configPath}.`);
+        }
+        return tree;
+    };
+}
+function defaultProjectName(tree, requested) {
+    if (requested)
+        return requested;
+    const angularJson = tree.read('/angular.json')?.toString('utf-8');
+    if (!angularJson) {
+        throw new schematics_1.SchematicsException('[rivinia/modal] angular.json not found.');
+    }
+    const workspace = JSON.parse(angularJson);
+    if (workspace.defaultProject && typeof workspace.defaultProject === 'string') {
+        return workspace.defaultProject;
+    }
+    const names = Object.keys(workspace.projects ?? {});
+    if (names.length === 0) {
+        throw new schematics_1.SchematicsException('[rivinia/modal] no projects in angular.json.');
+    }
+    return names[0];
+}
+function findAppConfig(tree, requestedProject) {
+    const angularJson = tree.read('/angular.json')?.toString('utf-8');
+    if (!angularJson)
+        return null;
+    const workspace = JSON.parse(angularJson);
+    const name = defaultProjectName(tree, requestedProject);
+    const project = workspace.projects?.[name];
+    if (!project)
+        return null;
+    const sourceRoot = project.sourceRoot ?? (project.root ? `${project.root}/src` : 'src');
+    return `/${sourceRoot}/app/app.config.ts`;
+}
+function insertAfterLastImport(content, line) {
+    const lines = content.split('\n');
+    let idx = -1;
+    for (let i = 0; i < lines.length; i++) {
+        if (/^\s*import\s/.test(lines[i]))
+            idx = i;
+    }
+    lines.splice(idx + 1, 0, line);
+    return lines.join('\n');
+}
+function insertProvider(content, call) {
+    const match = /providers\s*:\s*\[/.exec(content);
+    if (!match) {
+        throw new schematics_1.SchematicsException('[rivinia/modal] no `providers: [` array found in app.config.ts — add providers manually.');
+    }
+    const at = match.index + match[0].length;
+    return `${content.slice(0, at)}\n    ${call},${content.slice(at)}`;
+}

package/schematics/ng-add/schema.json

@@ -0,0 +1,19 @@
+{
+  "$schema": "http://json-schema.org/schema",
+  "$id": "rivinia-modal-ng-add",
+  "title": "Rivinia Modal ng-add options",
+  "type": "object",
+  "properties": {
+    "strategy": {
+      "type": "string",
+      "description": "Ordering policy for provideRiviniaModal({ strategy }). Omit for the 'stack' default.",
+      "enum": ["stack", "queue"]
+    },
+    "project": {
+      "type": "string",
+      "description": "Angular CLI project name — only for multi-app workspaces. Defaults to the workspace default project.",
+      "default": ""
+    }
+  },
+  "required": []
+}

package/types/rivinia-modal.d.ts

@@ -0,0 +1,340 @@
+import * as i0 from "@angular/core";
+import { DestroyRef, EnvironmentProviders, InjectionToken, TemplateRef, Type } from "@angular/core";
+/**
+ * Ordering/admission policy. Strategies are pure with respect to lifecycle:
+ * the manager owns identity, results, timers and disposal; strategies own
+ * ordering and activation width. No mode-dependent `if/else` in the manager.
+ */
+interface ModalStrategy {
+  readonly name: string;
+  /** Maximum simultaneously active instances under this strategy. */
+  maxActive(maxVisible: number): number;
+  /**
+   * Admission of a new request given current visible/queued sets.
+   * Returns the action; the manager executes it (and settles results).
+   */
+  admit(visibleCount: number, queuedCount: number, maxVisible: number): 'activate' | 'queue';
+  /** Display order of visible instances, bottom-first. */
+  order<T extends {
+    readonly openedSeq: number;
+  }>(visible: readonly T[]): readonly T[];
+}
+/** Multiple concurrent modals, topmost (last opened) interactive. */
+export declare class StackStrategy implements ModalStrategy {
+  readonly name = "stack";
+  maxActive(maxVisible: number): number;
+  admit(visibleCount: number, _queuedCount: number, maxVisible: number): 'activate' | 'queue';
+  order<T extends {
+    readonly openedSeq: number;
+  }>(visible: readonly T[]): readonly T[];
+}
+/** Strictly serial: one active modal, FIFO activation of the rest. */
+export declare class QueueStrategy implements ModalStrategy {
+  readonly name = "queue";
+  maxActive(_maxVisible: number): number;
+  admit(visibleCount: number, _queuedCount: number, _maxVisible: number): 'activate' | 'queue';
+  order<T extends {
+    readonly openedSeq: number;
+  }>(visible: readonly T[]): readonly T[];
+}
+/**
+ * Discriminated result of a modal request. Every terminal path settles exactly
+ * once — infrastructure failures reject the promise instead of becoming variants.
+ */
+type ModalResult<T> = {
+  readonly status: 'confirmed';
+  readonly value: T;
+} | {
+  readonly status: 'cancelled';
+  readonly reason?: string;
+} | {
+  readonly status: 'dismissed';
+  readonly reason?: string;
+} | {
+  readonly status: 'owner-destroyed';
+} | {
+  readonly status: 'queued-cancelled';
+} | {
+  readonly status: 'rejected';
+  readonly reason?: string;
+};
+/** Lifecycle state of one modal instance. Single source of truth: the manager. */
+type ModalStatus = 'queued' | 'active' | 'closing' | 'closed';
+/** Origin of a dismissal intent. Guards see it; forced paths bypass guards. */
+type ModalDismissOrigin = 'escape' | 'backdrop' | 'button' | 'program' | 'system';
+/** Content a modal renders. Core stores the descriptor; UI interprets it. */
+type ModalContent<TData> = {
+  readonly kind: 'template';
+  readonly template: TemplateRef<ModalTemplateContext<TData>>;
+} | {
+  readonly kind: 'component';
+  readonly component: Type<unknown>;
+  readonly inputs?: Record<string, unknown>;
+};
+/** Template context for `TemplateRef` content. */
+interface ModalTemplateContext<TData> {
+  /** Typed input data (`let-data`). */
+  readonly $implicit: TData;
+  /** Modal operations (`let-modal="modal"`). */
+  readonly modal: ModalContext<TData>;
+}
+/**
+ * Operations exposed to modal content (injected token value for components,
+ * template context for templates). Scoped to ONE instance — never global.
+ */
+interface ModalContext<TData> {
+  readonly id: string;
+  readonly data: TData;
+  readonly parentId: string | null;
+  close(result?: unknown): boolean;
+  dismiss(reason?: string): boolean;
+}
+/**
+ * Guard hook run by `requestDismiss` (user intents: escape/backdrop/button,
+ * or explicit programmatic review). Return `false` (or a rejecting promise)
+ * to deny. Throwing denies safely. Never blocks forced disposal.
+ */
+type ModalGuard = (context: {
+  readonly id: string;
+  readonly origin: ModalDismissOrigin;
+}) => boolean | Promise<boolean>;
+/** Dismissal policy: global defaults, per-open overrides win. */
+interface ModalDismissPolicy {
+  /** Escape closes the topmost eligible modal. @default true */
+  readonly closeOnEscape?: boolean;
+  /** Backdrop click behavior. @default 'close' */
+  readonly backdrop?: 'close' | 'static' | 'disabled';
+}
+/** Overflow behavior when capacity is full. @default 'queue' (lossless). */
+type ModalOverflowPolicy = 'dismiss-oldest' | 'queue' | 'reject';
+/** What closing a parent does to its descendants. */
+type DescendantPolicy = 'close-with-parent' | 'prevent-parent-close';
+/** Public, UI-consumable snapshot of one modal instance. */
+interface ModalInstance<TData = unknown> {
+  readonly id: string;
+  /** Stable key for a modal definition (e.g. `'confirm-delete'`). */
+  readonly ref: string | null;
+  /** Request origin label for diagnostics (e.g. component/feature name). */
+  readonly caller: string | null;
+  readonly parentId: string | null;
+  readonly data: TData;
+  readonly content: ModalContent<TData>;
+  readonly status: ModalStatus;
+  readonly dismiss: ModalDismissPolicy;
+  readonly metadata: Readonly<Record<string, unknown>>;
+}
+/**
+ * Caller-side handle. `result` settles exactly once per the manager contract;
+ * repeated terminal calls are safe no-ops returning `false`.
+ */
+interface ModalHandle<TResult = unknown> {
+  readonly id: string;
+  readonly result: Promise<ModalResult<TResult>>;
+  close(result?: TResult): boolean;
+  dismiss(reason?: string): boolean;
+  cancel(reason?: string): boolean;
+}
+/** Arguments to `openModal()`. */
+interface ModalOpenOptions<TData = unknown> {
+  readonly data?: TData;
+  readonly ref?: string;
+  readonly caller?: string;
+  readonly parentId?: string;
+  /**
+   * Lifecycle owner. Destruction settles active modals as `owner-destroyed`
+   * and queued ones as `queued-cancelled`. Default: independent lifetime.
+   */
+  readonly owner?: DestroyRef;
+  /** Named preset from global config (explicit options always win). */
+  readonly preset?: string;
+  readonly dismiss?: Partial<ModalDismissPolicy>;
+  readonly guards?: readonly ModalGuard[];
+  readonly metadata?: Record<string, unknown>;
+}
+/** Partial changes for `update()` (content shape itself is immutable). */
+interface ModalUpdate<TData = unknown> {
+  readonly data?: TData;
+  readonly metadata?: Record<string, unknown>;
+}
+/** Bounded diagnostic record. Never carries payloads. */
+interface ModalDiagnostic {
+  readonly seq: number;
+  readonly type: 'opened' | 'activated' | 'queued' | 'promoted' | 'closing' | 'closed' | 'dismissed' | 'rejected' | 'guard-denied' | 'strategy-rejected';
+  readonly id: string;
+  readonly ref: string | null;
+  readonly reason?: string;
+}
+/** Named preset: a reusable dismissal shape (explicit options always win). */
+interface ModalPreset {
+  readonly dismiss?: Partial<ModalDismissPolicy>;
+}
+/**
+ * Global configuration for `@rivinia/modal`. Everything optional; per-open
+ * options win. No styling, positions, icons, or translations here — ever.
+ */
+interface RiviniaModalConfig {
+  /**
+   * Ordering/activation policy. `'stack'` = up to `maxVisible` concurrent,
+   * topmost interactive. `'queue'` = strictly serial (one active, FIFO rest).
+   * A custom `ModalStrategy` instance is also accepted.
+   * @default 'stack'
+   */
+  readonly strategy?: 'stack' | 'queue' | ModalStrategy;
+  /** Global dismissal defaults. @default { closeOnEscape: true, backdrop: 'close' } */
+  readonly dismiss?: ModalDismissPolicy;
+  /** Capacity of simultaneously active modals. Clamped to ≥ 1. @default 5 */
+  readonly maxVisible?: number;
+  /** Bound for queued requests (queue policy). @default Infinity */
+  readonly maxQueue?: number;
+  /** Overflow behavior when full. @default 'queue' (lossless — never drops input) */
+  readonly overflow?: ModalOverflowPolicy;
+  /** Parent closure with remaining descendants. @default 'close-with-parent' */
+  readonly descendants?: DescendantPolicy;
+  /** Named dismissal presets referenced by `openModal({ preset })`. */
+  readonly presets?: Record<string, ModalPreset>;
+  /**
+   * Time the manager waits for UI teardown confirmation (`confirmClosed`)
+   * before auto-finalizing a `closing` instance. `0` = manual only.
+   * @default 300
+   */
+  readonly closingTimeout?: number;
+  /**
+   * Bounded transition log for debugging (ring buffer, no payloads).
+   * Off by default to stay production-light.
+   * @default false
+   */
+  readonly diagnostics?: boolean;
+}
+/**
+ * Internal configuration token. Consumers must use `provideRiviniaModal()`.
+ * @internal
+ */
+declare const RIVINIA_MODAL_CONFIG: InjectionToken<RiviniaModalConfig>;
+declare const DEFAULT_MAX_VISIBLE = 5;
+declare const DEFAULT_CLOSING_TIMEOUT = 300;
+declare const DIAGNOSTIC_CAP = 100;
+/**
+ * Injection token providing the `ModalContext` of the enclosing modal to
+ * dynamically created components. Template content receives the same object
+ * as `let-modal="modal"`. Never global — one value per modal instance.
+ */
+export declare const RIVINIA_MODAL_CONTEXT: InjectionToken<ModalContext<unknown>>;
+/**
+ * Headless modal manager. Owns identity, lifecycle coordination, result
+ * settlement and diagnostics. Ordering/admission policy is delegated to a
+ * `ModalStrategy` (Stack/Queue/custom) — the manager never branches on mode.
+ *
+ * Settlement contract (each path settles exactly once, never hangs):
+ * - `close()` on active → `confirmed` · `dismiss()` on active → `dismissed`
+ * - `cancel()` on active → `cancelled` · on queued → `queued-cancelled`
+ * - `dismiss()` on queued → `dismissed` with the reason (pre-activation)
+ * - overflow/guard refusal → `rejected` · owner gone → `owner-destroyed`
+ * - forced paths (owner, overflow eviction, `dismissAll`) bypass guards
+ * - `close/dismiss/cancel` are guard-free primitives; `requestDismiss` runs
+ *   guards for user intents (escape/backdrop/button) or explicit review
+ * - infrastructure failures reject the promise — never a result variant
+ *
+ * Results settle at dismissal initiation, not after UI teardown: animations
+ * never delay callers. The `closing` → `closed` handshake (`confirmClosed`
+ * or `closingTimeout` auto-finalize) exists only for exit animations.
+ */
+export declare class RiviniaModal {
+  private readonly config;
+  private readonly _instances;
+  private readonly _results;
+  private _strategy;
+  private _seq;
+  private _diagSeq;
+  private readonly _diagnostics;
+  /** Active instances in strategy display order (bottom-first). */
+  readonly active: import("@angular/core").Signal<readonly ModalInstance<unknown>[]>;
+  /** Queued instances, FIFO admission order. */
+  readonly queued: import("@angular/core").Signal<readonly ModalInstance<unknown>[]>;
+  /** Topmost active instance (the only Escape-eligible one), if any. */
+  readonly top: import("@angular/core").Signal<ModalInstance<unknown> | null>;
+  constructor();
+  openModal<TData = unknown, TResult = unknown>(content: ModalContent<TData>, options?: ModalOpenOptions<TData>): ModalHandle<TResult>;
+  /**
+   * Confirms with a value. Active instances only; settles `confirmed`.
+   * Blocked (returns `false`) by the prevent-parent-close policy.
+   */
+  close(id: string, value?: unknown): boolean;
+  /**
+   * Guard-free dismissal primitive. Active → `dismissed`; queued → removed as
+   * `dismissed` with the reason. Blocked by prevent-parent-close.
+   */
+  dismiss(id: string, reason?: string): boolean;
+  /**
+   * Cancels: active → `cancelled`, queued → removed as `queued-cancelled`.
+   * Blocked by prevent-parent-close. Closing/closed/unknown → `false`.
+   */
+  cancel(id: string, reason?: string): boolean;
+  /**
+   * Guarded dismissal for user intents (escape/backdrop/button) or explicit
+   * programmatic review. Guards run sequentially; any `false` or throw denies
+   * (stays open + diagnostic). Stale guard completions are ignored.
+   */
+  requestDismiss(id: string, origin: ModalDismissOrigin, reason?: string): Promise<boolean>;
+  /** Merges data/metadata (new object identity so UI re-renders). */
+  update<TData>(id: string, changes: ModalUpdate<TData>): boolean;
+  /** UI teardown confirmation after exit animations. Auto-finalizes via timeout. */
+  confirmClosed(id: string): boolean;
+  /** Forced cleanup (bypasses guards): active → `dismissed`, queued → `queued-cancelled`. */
+  dismissAll(reason?: string): void;
+  /** Non-closed snapshots for a definition ref (e.g. avoid duplicate confirms). */
+  findByRef(ref: string): ModalInstance[];
+  /**
+   * Swaps the strategy. Rejected with an explicit error while any instance is
+   * not closed — silent live migration is never attempted.
+   */
+  useStrategy(strategy: ModalStrategy): void;
+  /** Introspection snapshot. Active means interactive; closing instances are
+   * still rendered (exit animations) until `confirmClosed`/timeout finalizes. */
+  debugState(): {
+    strategy: string;
+    active: string[];
+    closing: string[];
+    queued: string[];
+  };
+  /** Bounded transition log (only when `diagnostics: true`). */
+  getDiagnostics(): readonly ModalDiagnostic[];
+  clearDiagnostics(): void;
+  private get;
+  private queuedCount;
+  private orderedActive;
+  private maxVisible;
+  private maxQueue;
+  private presetDismiss;
+  private knownParent;
+  /** Overflow handling for queue-intent admissions. Returns rejection reason, or the resulting status. */
+  private admitQueued;
+  private blockedByDescendants;
+  private beginClosing;
+  private closeDescendants;
+  private finalize;
+  private promote;
+  private remove;
+  private clearClosingTimer;
+  private teardownOwned;
+  private patch;
+  private deferred;
+  private settle;
+  private diagnose;
+  private resolveStrategy;
+  static ɵfac: i0.ɵɵFactoryDeclaration<RiviniaModal, never>;
+  static ɵprov: i0.ɵɵInjectableDeclaration<any>;
+}
+/**
+ * Configures `@rivinia/modal`. The manager is a root singleton; call once at
+ * bootstrap. Per-open options always win over these globals. No styling,
+ * positions, or icons here — ever.
+ *
+ * @example
+ * ```ts
+ * provideRiviniaModal({ strategy: 'stack', maxVisible: 3 })
+ * ```
+ */
+export declare function provideRiviniaModal(config?: RiviniaModalConfig): EnvironmentProviders;
+/** Shorthand for `inject(RiviniaModal)`. */
+export declare function injectRiviniaModal(): RiviniaModal;
+export type { DescendantPolicy, ModalContent, ModalContext, ModalDiagnostic, ModalDismissOrigin, ModalDismissPolicy, ModalGuard, ModalHandle, ModalInstance, ModalOpenOptions, ModalOverflowPolicy, ModalPreset, ModalResult, ModalStatus, ModalStrategy, ModalTemplateContext, ModalUpdate, RiviniaModalConfig };