@cdevhub/ngx-tw 0.4.0 → 0.6.0

package/fesm2022/cdevhub-ngx-tw-dialog.mjs

@@ -1,11 +1,7 @@
 import * as i0 from '@angular/core';
-import { InjectionToken, inject, computed, ViewEncapsulation, ChangeDetectionStrategy, Component, signal, Injector, Injectable, makeEnvironmentProviders, Directive, input } from '@angular/core';
-import { DialogConfig, CdkDialogContainer, Dialog } from '@angular/cdk/dialog';
-import { createBlockScrollStrategy, createNoopScrollStrategy, createRepositionScrollStrategy, createCloseScrollStrategy } from '@angular/cdk/overlay';
-import { ReplaySubject, filter, take, merge, Subject, defer, startWith } from 'rxjs';
-import { CdkPortalOutlet } from '@angular/cdk/portal';
-import { OverlayContainerCoordinator, mergeOverlayPanelClass, coerceOverlayDuration } from '@cdevhub/ngx-tw/core';
-import { tv } from 'tailwind-variants';
+import { InjectionToken, signal, inject, Injector, Injectable, makeEnvironmentProviders, Directive, input, computed } from '@angular/core';
+import { ReplaySubject, Subject, filter, take, merge, defer, startWith } from 'rxjs';
+import { DialogConfig } from '@angular/cdk/dialog';
 import { ESCAPE, hasModifierKey } from '@angular/cdk/keycodes';
 import { _IdGenerator } from '@angular/cdk/a11y';
 import * as i1 from '@angular/cdk/scrolling';
@@ -55,130 +51,22 @@ const TW_DIALOG_DATA = new InjectionToken('TW_DIALOG_DATA');
 /** Injection token for application-wide default dialog options. Set via `provideTwDialog()`. */
 const TW_DIALOG_DEFAULT_OPTIONS = new InjectionToken('TW_DIALOG_DEFAULT_OPTIONS');
 
-// Dialog uses a `data-[state]` driven CSS transition rather than the project's
-// `animate.enter`/`animate.leave` keyframes. Justification:
-//   1. The ref owns the open/close lifecycle (state signal, observables) and
-//      needs runtime-configurable enter/exit durations per `TwDialog.open()`
-//      call — `animate.enter` only accepts a static class name.
-//   2. The container drives the same CSS variables (opacity + scale) for both
-//      transitions, so a single `transition-[opacity,transform]` rule with a
-//      data-state attribute is simpler than two keyframe declarations.
-// All other library overlays (popover, menu, tooltip) use animate.enter/leave;
-// this divergence is intentional and isolated to the dialog container.
-const dialogContainerVariants = tv({
-    slots: {
-        host: 'relative flex flex-col outline-none bg-surface-raised text-fg rounded-lg shadow-md border border-border overflow-hidden transition-[opacity,transform] ease-out motion-reduce:transition-none opacity-0 scale-95 data-[state=open]:opacity-100 data-[state=open]:scale-100 data-[state=closing]:opacity-0 data-[state=closing]:scale-95',
-    },
-    variants: {
-        size: {
-            xs: { host: 'w-full max-w-sm max-h-[85vh]' },
-            sm: { host: 'w-full max-w-md max-h-[85vh]' },
-            md: { host: 'w-full max-w-lg max-h-[85vh]' },
-            lg: { host: 'w-full max-w-2xl max-h-[85vh]' },
-            xl: { host: 'w-full max-w-4xl max-h-[85vh]' },
-            fullscreen: {
-                host: 'w-screen h-screen max-w-none max-h-none rounded-none border-0',
-            },
-        },
-    },
-    defaultVariants: { size: 'md' },
-}, { twMerge: true });
-/**
- * Dialog container rendered inside the CDK overlay. Wraps the user-provided
- * content in a Tailwind-styled surface and coordinates enter/exit transitions
- * with {@link TwDialogRef}.
- *
- * The animation state machine, `aria-describedby` queue, and panel-class
- * merge are shared with `SheetContainer` via {@link OverlayContainerCoordinator}
- * (component-scoped — see `providers: [OverlayContainerCoordinator]`).
- *
- * @docs-private
- */
-class DialogContainer extends CdkDialogContainer {
-    coordinator = inject(OverlayContainerCoordinator);
-    /** Lifecycle state of the dialog's enter/exit animation. */
-    state = this.coordinator.state;
-    /** Emits whenever the animation state transitions. */
-    animationStateChanged = this.coordinator.animationStateChanged;
-    /** Resolved enter-animation duration in ms. */
-    enterAnimationDuration;
-    /** Resolved exit-animation duration in ms. */
-    exitAnimationDuration;
-    sizeVariant = computed(() => {
-        const size = this._config.size ?? 'md';
-        return dialogContainerVariants({ size });
-    }, /* @ts-ignore */
-    ...(ngDevMode ? [{ debugName: "sizeVariant" }] : /* istanbul ignore next */ []));
-    hostClasses = computed(() => mergeOverlayPanelClass(this.sizeVariant().host(), this._config.panelClass), /* @ts-ignore */
-    ...(ngDevMode ? [{ debugName: "hostClasses" }] : /* istanbul ignore next */ []));
-    ariaDescribedByAttr = computed(() => this._config.ariaDescribedBy ||
-        this.coordinator.describedByIds()[0] ||
-        null, /* @ts-ignore */
-    ...(ngDevMode ? [{ debugName: "ariaDescribedByAttr" }] : /* istanbul ignore next */ []));
-    transitionDuration = this.coordinator.transitionDuration;
-    constructor() {
-        super();
-        this.enterAnimationDuration = coerceOverlayDuration(this._config.enterAnimationDuration, 150);
-        this.exitAnimationDuration = coerceOverlayDuration(this._config.exitAnimationDuration, 120);
-        this.coordinator.setDurations(this.enterAnimationDuration, this.exitAnimationDuration);
-    }
-    _contentAttached() {
-        super._contentAttached();
-        this.coordinator.startEnterAnimation();
-    }
-    /** Triggered by the dialog ref to play the exit transition before disposing the overlay. */
-    _startExitAnimation() {
-        this.coordinator.startExitAnimation();
-    }
-    /** Registers a description id for the container's `aria-describedby`. */
-    _addAriaDescribedBy(id) {
-        this.coordinator.addAriaDescribedBy(id);
-    }
-    /** Removes a previously registered description id. */
-    _removeAriaDescribedBy(id) {
-        this.coordinator.removeAriaDescribedBy(id);
-    }
-    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.0.7", ngImport: i0, type: DialogContainer, deps: [], target: i0.ɵɵFactoryTarget.Component });
-    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "22.0.7", type: DialogContainer, isStandalone: true, selector: "tw-dialog-container", host: { attributes: { "tabindex": "-1" }, properties: { "attr.id": "_config.id || null", "attr.role": "_config.role", "attr.aria-modal": "_config.ariaModal", "attr.aria-labelledby": "_config.ariaLabel ? null : _ariaLabelledByQueue[0]", "attr.aria-label": "_config.ariaLabel", "attr.aria-describedby": "ariaDescribedByAttr()", "attr.data-state": "state()", "class": "hostClasses()", "style.transition-duration.ms": "transitionDuration()" } }, providers: [OverlayContainerCoordinator], usesInheritance: true, ngImport: i0, template: '<ng-template cdkPortalOutlet />', isInline: true, dependencies: [{ kind: "directive", type: CdkPortalOutlet, selector: "[cdkPortalOutlet]", inputs: ["cdkPortalOutlet"], outputs: ["attached"], exportAs: ["cdkPortalOutlet"] }], changeDetection: i0.ChangeDetectionStrategy.OnPush, encapsulation: i0.ViewEncapsulation.None });
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.0.7", ngImport: i0, type: DialogContainer, decorators: [{
-            type: Component,
-            args: [{
-                    selector: 'tw-dialog-container',
-                    template: '<ng-template cdkPortalOutlet />',
-                    changeDetection: ChangeDetectionStrategy.OnPush,
-                    encapsulation: ViewEncapsulation.None,
-                    imports: [CdkPortalOutlet],
-                    providers: [OverlayContainerCoordinator],
-                    host: {
-                        tabindex: '-1',
-                        '[attr.id]': '_config.id || null',
-                        '[attr.role]': '_config.role',
-                        '[attr.aria-modal]': '_config.ariaModal',
-                        '[attr.aria-labelledby]': '_config.ariaLabel ? null : _ariaLabelledByQueue[0]',
-                        '[attr.aria-label]': '_config.ariaLabel',
-                        '[attr.aria-describedby]': 'ariaDescribedByAttr()',
-                        '[attr.data-state]': 'state()',
-                        '[class]': 'hostClasses()',
-                        '[style.transition-duration.ms]': 'transitionDuration()',
-                    },
-                }]
-        }], ctorParameters: () => [] });
-
 /**
  * Reference to a dialog opened via {@link TwDialog.open}. Drives the dialog
  * lifecycle (close, state, observables) and forwards useful overlay streams.
+ *
+ * The ref is returned **synchronously** from `open()`, but the dialog's render
+ * layer (`@angular/cdk/dialog` + the Tailwind container) is loaded through a
+ * dynamic `import()`. The ref therefore starts *detached*: `id`, `state`,
+ * `close()`, the lifecycle observables, and panel/size mutations all work
+ * immediately (mutations are buffered and replayed on attach), but the rendered
+ * component instance does not exist yet — read it via {@link whenComponentReady}
+ * instead of a synchronous `componentInstance` field.
  */
 class TwDialogRef {
-    cdkRef;
     config;
-    containerInstance;
-    /** Unique ID of the dialog. */
+    /** Unique ID of the dialog. Generated eagerly by the service, so it is valid the instant `open()` returns. */
     id;
-    /** Instance of the component rendered inside the dialog, or `null` for template dialogs. */
-    componentInstance = null;
-    /** `ComponentRef` of the content component, or `null` for template dialogs. */
-    componentRef = null;
     /** Current lifecycle state. Reactively readable. */
     state;
     /** When `true`, close-via-escape and close-via-backdrop are disabled. */
@@ -188,17 +76,67 @@ class TwDialogRef {
     afterOpenedSubject = new ReplaySubject(1);
     beforeClosedSubject = new ReplaySubject(1);
     afterClosedSubject = new ReplaySubject(1);
+    // Facade-owned pass-throughs for the raw overlay streams, so a consumer that
+    // subscribes before the render chunk attaches still receives events once it
+    // does — the pre-deferral behaviour when `open()` wrapped a live `cdkRef`.
+    backdropClickSubject = new Subject();
+    keydownEventsSubject = new Subject();
+    cdkRef = null;
+    container = null;
+    componentInstanceValue = null;
+    componentRefValue = null;
+    resolveComponentReady;
+    componentReadyPromise = new Promise((resolve) => {
+        this.resolveComponentReady = resolve;
+    });
+    // Buffered mutations issued before the render chunk attached the CDK backend.
+    pendingPanelAdds = [];
+    pendingPanelRemoves = [];
+    pendingSize = null;
     pendingResult;
     closeFocusOrigin;
-    constructor(cdkRef, config, containerInstance) {
-        this.cdkRef = cdkRef;
+    constructor(id, config) {
         this.config = config;
-        this.containerInstance = containerInstance;
-        this.id = cdkRef.id;
+        this.id = id;
         this.disableClose = config.disableClose;
         this.state = this.stateSignal.asReadonly();
+    }
+    /**
+     * The Tailwind container instance, or `null` until the dialog has attached.
+     * `null` is the normal value for the first tick after `open()` returns,
+     * because the render layer is loaded through a dynamic `import()`.
+     *
+     * Only `state`, `animationStateChanged`, `enterAnimationDuration` and
+     * `exitAnimationDuration` are supported reads; the `_`-prefixed members are
+     * library-internal wiring and may change without a major bump. Prefer
+     * {@link state} and {@link afterOpened} on the ref itself.
+     */
+    get containerInstance() {
+        return this.container;
+    }
+    /**
+     * @internal Wire this facade to its CDK backend. Called from the dialog
+     * renderer **inside** `cdkDialog.open()`'s `providers` callback — the same
+     * point the constructor ran before deferral — so subscriptions to
+     * `animationStateChanged` are in place before the container emits `'open'`.
+     */
+    _attach(cdkRef, container) {
+        this.cdkRef = cdkRef;
+        this.container = container;
+        // Forward the raw overlay streams into the facade pass-throughs.
+        cdkRef.backdropClick.subscribe(this.backdropClickSubject);
+        cdkRef.keydownEvents.subscribe(this.keydownEventsSubject);
         cdkRef.addPanelClass('tw-dialog-panel');
-        const animationChanges = containerInstance.animationStateChanged;
+        for (const cls of this.pendingPanelAdds)
+            cdkRef.addPanelClass(cls);
+        for (const cls of this.pendingPanelRemoves)
+            cdkRef.removePanelClass(cls);
+        if (this.pendingSize)
+            cdkRef.updateSize(this.pendingSize[0], this.pendingSize[1]);
+        this.pendingPanelAdds.length = 0;
+        this.pendingPanelRemoves.length = 0;
+        this.pendingSize = null;
+        const animationChanges = container.animationStateChanged;
         animationChanges
             .pipe(filter((event) => event.state === 'open'), take(1))
             .subscribe(() => {
@@ -226,6 +164,38 @@ class TwDialogRef {
             this.closeWithOrigin(event.type === 'keydown' ? 'keyboard' : 'mouse');
         });
     }
+    /** @internal Record the rendered component after `cdkDialog.open()` returns. */
+    _setComponent(instance, ref) {
+        this.componentInstanceValue = instance;
+        this.componentRefValue = ref;
+        this.resolveComponentReady(instance);
+    }
+    /**
+     * Resolves with the rendered content-component instance once the dialog's
+     * render chunk has loaded and attached. Resolves `null` for template dialogs,
+     * and for a dialog closed before it ever opened.
+     *
+     * Replaces the former synchronous `componentInstance` field, which cannot be
+     * populated before the deferred render chunk lands.
+     *
+     * @example
+     * ```ts
+     * const ref = dialog.open(EditorDialog);
+     * const editor = await ref.whenComponentReady();
+     * editor?.focusFirstField();
+     * ```
+     */
+    whenComponentReady() {
+        return this.componentReadyPromise;
+    }
+    /** The rendered component instance, or `null` if not yet attached / a template dialog. Prefer {@link whenComponentReady}. */
+    get componentInstance() {
+        return this.componentInstanceValue;
+    }
+    /** The rendered `ComponentRef`, or `null` if not yet attached / a template dialog. */
+    get componentRef() {
+        return this.componentRefValue;
+    }
     /**
      * Closes the dialog. The exit animation runs before the overlay is disposed.
      * @param result Value forwarded to `afterClosed()` subscribers.
@@ -245,27 +215,42 @@ class TwDialogRef {
     afterClosed() {
         return this.afterClosedSubject.asObservable();
     }
-    /** Backdrop click stream (emits even when `disableClose` is set). */
+    /** Backdrop click stream (emits even when `disableClose` is set). Buffered — a subscription made before the dialog attaches receives events once it does. */
     backdropClick() {
-        return this.cdkRef.backdropClick;
+        return this.backdropClickSubject.asObservable();
     }
-    /** Keydown event stream for the overlay. */
+    /** Keydown event stream for the overlay. Buffered — a subscription made before the dialog attaches receives events once it does. */
     keydownEvents() {
-        return this.cdkRef.keydownEvents;
+        return this.keydownEventsSubject.asObservable();
     }
-    /** Updates the dialog's width/height. Pass empty string to reset a dimension. */
+    /** Updates the dialog's width/height. Pass empty string to reset a dimension. Buffered until attach. */
     updateSize(width = '', height = '') {
-        this.cdkRef.updateSize(width, height);
+        if (this.cdkRef) {
+            this.cdkRef.updateSize(width, height);
+        }
+        else {
+            this.pendingSize = [width, height];
+        }
         return this;
     }
-    /** Adds CSS classes to the overlay panel. */
+    /** Adds CSS classes to the overlay panel. Buffered until attach. */
     addPanelClass(classes) {
-        this.cdkRef.addPanelClass(classes);
+        if (this.cdkRef) {
+            this.cdkRef.addPanelClass(classes);
+        }
+        else {
+            this.pendingPanelAdds.push(...(Array.isArray(classes) ? classes : [classes]));
+        }
         return this;
     }
-    /** Removes CSS classes from the overlay panel. */
+    /** Removes CSS classes from the overlay panel. Buffered until attach. */
     removePanelClass(classes) {
-        this.cdkRef.removePanelClass(classes);
+        if (this.cdkRef) {
+            this.cdkRef.removePanelClass(classes);
+        }
+        else {
+            this.pendingPanelRemoves.push(...(Array.isArray(classes) ? classes : [classes]));
+        }
         return this;
     }
     closeWithOrigin(origin, result) {
@@ -273,7 +258,7 @@ class TwDialogRef {
             return;
         const predicate = this.config.closePredicate;
         if (predicate &&
-            !predicate(result, this.config, this.componentInstance)) {
+            !predicate(result, this.config, this.componentInstanceValue)) {
             return;
         }
         this.pendingResult = result;
@@ -281,8 +266,15 @@ class TwDialogRef {
         this.stateSignal.set('closing');
         this.beforeClosedSubject.next(result);
         this.beforeClosedSubject.complete();
+        if (!this.cdkRef) {
+            // Closed before the render chunk attached: the overlay was never created,
+            // so there is nothing to animate or dispose. Synthesize the closed state
+            // and let the service skip opening entirely (it checks state()).
+            this.finishClose();
+            return;
+        }
         this.cdkRef.overlayRef.detachBackdrop();
-        this.containerInstance._startExitAnimation();
+        this.container._startExitAnimation();
     }
     finishClose() {
         if (this.stateSignal() === 'closed')
@@ -290,25 +282,41 @@ class TwDialogRef {
         this.stateSignal.set('closed');
         this.afterClosedSubject.next(this.pendingResult);
         this.afterClosedSubject.complete();
-        if (this.cdkRef.containerInstance) {
+        // Idempotent — a no-op if _setComponent already resolved with an instance.
+        this.resolveComponentReady(null);
+        this.backdropClickSubject.complete();
+        this.keydownEventsSubject.complete();
+        if (this.cdkRef?.containerInstance) {
             this.cdkRef.close(this.pendingResult, { focusOrigin: this.closeFocusOrigin });
         }
-        this.componentInstance = null;
+        this.componentInstanceValue = null;
     }
 }
 
+let nextDialogId = 0;
+function generateDialogId() {
+    return `tw-dialog-${++nextDialogId}`;
+}
 /**
  * Opens Tailwind-styled modal dialogs. Composes `@angular/cdk/dialog` for focus
  * trapping, portals, overlay plumbing, and adds a Tailwind container, richer
  * ref API, and animation lifecycle.
  *
+ * The rendering layer (`@angular/cdk/dialog` + the Tailwind container) is loaded
+ * through a dynamic `import()` on the first `open()` call, so merely registering
+ * this service costs nothing in the initial bundle. `open()` still returns its
+ * {@link TwDialogRef} synchronously — the dialog is rendered once the chunk
+ * lands. Read the rendered component via {@link TwDialogRef.whenComponentReady}.
+ *
  * Not `providedIn: 'root'` — register it via {@link provideTwDialog}.
  */
 class TwDialog {
-    cdkDialog = inject(Dialog);
     injector = inject(Injector);
     defaultOptions = inject(TW_DIALOG_DEFAULT_OPTIONS, { optional: true }) ?? {};
     parentDialog = inject(TwDialog, { optional: true, skipSelf: true });
+    /** Cached renderer chunk import — kicked off on the first `open()`. */
+    rendererPromise = null;
+    destroyed = false;
     openDialogsAtThisLevel = signal([], /* @ts-ignore */
     ...(ngDevMode ? [{ debugName: "openDialogsAtThisLevel" }] : /* istanbul ignore next */ []));
     afterOpenedSubject = new Subject();
@@ -332,64 +340,25 @@ class TwDialog {
      * Opens a dialog using the given component or template.
      * @param content Component class or `TemplateRef`.
      * @param config Options merged over the application defaults.
-     * @returns Reference controlling the opened dialog.
+     * @returns Reference controlling the opened dialog, returned synchronously.
      */
     open(content, config) {
         const merged = this.resolveConfig(config);
-        let twRef;
-        const cdkRef = this.cdkDialog.open(content, {
-            id: merged.id,
-            role: merged.role,
-            data: merged.data,
-            panelClass: merged.panelClass,
-            backdropClass: merged.backdropClass ?? 'tw-dialog-backdrop',
-            hasBackdrop: merged.hasBackdrop,
-            width: merged.width,
-            height: merged.height,
-            minWidth: merged.minWidth,
-            minHeight: merged.minHeight,
-            maxWidth: merged.maxWidth,
-            maxHeight: merged.maxHeight,
-            direction: merged.direction,
-            ariaDescribedBy: merged.ariaDescribedBy,
-            ariaLabelledBy: merged.ariaLabelledBy,
-            ariaLabel: merged.ariaLabel,
-            ariaModal: merged.ariaModal,
-            autoFocus: merged.autoFocus,
-            restoreFocus: merged.restoreFocus,
-            scrollStrategy: merged.scrollStrategy ?? this.resolveScrollStrategy(merged.scrollBehavior),
-            closeOnNavigation: merged.closeOnNavigation,
-            viewContainerRef: merged.viewContainerRef,
-            injector: merged.injector,
-            // We handle close/Escape/backdrop ourselves so we can run the exit animation.
-            disableClose: true,
-            closeOnOverlayDetachments: false,
-            container: {
-                type: DialogContainer,
-                providers: () => [
-                    { provide: TwDialogConfig, useValue: merged },
-                    { provide: DialogConfig, useValue: merged },
-                ],
-            },
-            providers: (_cdkRef, _cdkConfig, container) => {
-                twRef = new TwDialogRef(_cdkRef, merged, container);
-                const providers = [
-                    { provide: TwDialogRef, useValue: twRef },
-                    { provide: TW_DIALOG_DATA, useValue: merged.data ?? null },
-                ];
-                if (Array.isArray(merged.providers))
-                    providers.push(...merged.providers);
-                return providers;
-            },
-        });
-        // After CDK attaches the component, copy references onto our ref.
-        twRef.componentRef = cdkRef.componentRef;
-        twRef.componentInstance = cdkRef.componentInstance;
+        const id = merged.id ?? generateDialogId();
+        merged.id = id;
+        // Enforce id uniqueness eagerly. CDK throws this synchronously from
+        // `open()`; since our CDK open is now deferred, replicate the check here so
+        // the error still surfaces at the call site rather than in a later tick.
+        if (this.getDialogById(id)) {
+            throw new Error(`Dialog with id "${id}" exists already. The dialog id must be unique.`);
+        }
+        const twRef = new TwDialogRef(id, merged);
         const scope = this.parentDialog ?? this;
         scope.registerOpen(twRef);
         twRef.afterClosed().subscribe(() => {
             scope.unregister(twRef);
         });
+        void this.renderWhenReady(content, merged, twRef);
         return twRef;
     }
     /** Closes every open dialog managed by this service (and child services). */
@@ -403,12 +372,42 @@ class TwDialog {
         return this.openDialogs().find((dialog) => dialog.id === id);
     }
     ngOnDestroy() {
+        this.destroyed = true;
         const dialogs = [...this.openDialogsAtThisLevel()];
         for (let i = dialogs.length - 1; i >= 0; i--)
             dialogs[i].close();
         this.afterOpenedSubject.complete();
         this.afterAllClosedSubject.complete();
     }
+    /**
+     * @internal Resolves once the renderer chunk has loaded. Exposed for tests,
+     * which must await the dynamic import before asserting on rendered DOM.
+     */
+    async _whenRendered() {
+        await this.loadRenderer();
+        await Promise.resolve();
+    }
+    /**
+     * Render a dialog once the renderer chunk has loaded. The ref was already
+     * returned to the caller, so it may have been closed (or the service
+     * destroyed) while the import was in flight — both skip the actual open.
+     */
+    async renderWhenReady(content, merged, twRef) {
+        const openRendered = await this.loadRenderer();
+        if (!openRendered || this.destroyed)
+            return;
+        // Closed before the chunk landed — the facade already synthesized its
+        // closed state; never create the overlay.
+        if (twRef.state() === 'closed')
+            return;
+        openRendered(this.injector, content, merged, twRef);
+    }
+    loadRenderer() {
+        if (!this.rendererPromise) {
+            this.rendererPromise = import('./cdevhub-ngx-tw-dialog-dialog-renderer-DoIhoV3d.mjs').then(({ openRenderedDialog }) => this.destroyed ? null : openRenderedDialog);
+        }
+        return this.rendererPromise;
+    }
     registerOpen(ref) {
         if (this.parentDialog) {
             this.parentDialog.registerOpen(ref);
@@ -439,19 +438,6 @@ class TwDialog {
         Object.assign(merged, this.defaultOptions, config);
         return merged;
     }
-    resolveScrollStrategy(strategy) {
-        switch (strategy) {
-            case 'close':
-                return createCloseScrollStrategy(this.injector);
-            case 'reposition':
-                return createRepositionScrollStrategy(this.injector);
-            case 'noop':
-                return createNoopScrollStrategy();
-            case 'block':
-            default:
-                return createBlockScrollStrategy(this.injector);
-        }
-    }
     static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.0.7", ngImport: i0, type: TwDialog, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
     static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "22.0.7", ngImport: i0, type: TwDialog });
 }
@@ -540,21 +526,16 @@ class DialogTitleDirective {
     dialogRef = inject(TwDialogRef, {
         optional: true,
     });
-    // Ancestor-DI fallback for the rare case where `TwDialogRef` is not in the
-    // directive's injector chain (e.g. heavily nested template portals). The
-    // container ALWAYS resolves via element-injector traversal because the
-    // directive lives inside `<tw-dialog-container>`'s DOM tree.
-    container = inject(DialogContainer, { optional: true, skipSelf: true });
     /** Custom id for the title element. Defaults to a generated unique id. */
     id = input(this.generatedId, /* @ts-ignore */
     ...(ngDevMode ? [{ debugName: "id" }] : /* istanbul ignore next */ []));
     ngOnInit() {
-        const containerInstance = this.dialogRef?.containerInstance ?? this.container;
+        const containerInstance = this.dialogRef?.containerInstance;
         if (containerInstance)
             containerInstance._addAriaLabelledBy(this.id());
     }
     ngOnDestroy() {
-        const containerInstance = this.dialogRef?.containerInstance ?? this.container;
+        const containerInstance = this.dialogRef?.containerInstance;
         if (containerInstance)
             containerInstance._removeAriaLabelledBy(this.id());
     }
@@ -595,18 +576,16 @@ class DialogDescriptionDirective {
     dialogRef = inject(TwDialogRef, {
         optional: true,
     });
-    // Ancestor-DI fallback — see DialogTitleDirective.
-    container = inject(DialogContainer, { optional: true, skipSelf: true });
     /** Custom id for the description element. Defaults to a generated unique id. */
     id = input(this.generatedId, /* @ts-ignore */
     ...(ngDevMode ? [{ debugName: "id" }] : /* istanbul ignore next */ []));
     ngOnInit() {
-        const containerInstance = this.dialogRef?.containerInstance ?? this.container;
+        const containerInstance = this.dialogRef?.containerInstance;
         if (containerInstance)
             containerInstance._addAriaDescribedBy(this.id());
     }
     ngOnDestroy() {
-        const containerInstance = this.dialogRef?.containerInstance ?? this.container;
+        const containerInstance = this.dialogRef?.containerInstance;
         if (containerInstance)
             containerInstance._removeAriaDescribedBy(this.id());
     }
@@ -672,7 +651,7 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.0.7", ngImpor
  * `[twDialogClose]` value to pass a result to `afterClosed()` subscribers.
  */
 class DialogCloseDirective {
-    /** Value passed to `afterClosed()` when the button is clicked. */
+    /** Value passed to `afterClosed()` when the button is clicked. Defaults to `undefined`. */
     twDialogClose = input(undefined, /* @ts-ignore */
     ...(ngDevMode ? [{ debugName: "twDialogClose" }] : /* istanbul ignore next */ []));
     /** Native button `type`. Defaults to `'button'` to avoid accidental form submission. */
@@ -702,5 +681,5 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.0.7", ngImpor
  * Generated bundle index. Do not edit.
  */
 
-export { DialogActionsDirective, DialogCloseDirective, DialogContainer, DialogContentDirective, DialogDescriptionDirective, DialogHeaderDirective, DialogIconDirective, DialogSubtitleDirective, DialogTitleDirective, TW_DIALOG_DATA, TW_DIALOG_DEFAULT_OPTIONS, TwDialog, TwDialogConfig, TwDialogRef, provideTwDialog };
+export { DialogActionsDirective, DialogCloseDirective, DialogContentDirective, DialogDescriptionDirective, DialogHeaderDirective, DialogIconDirective, DialogSubtitleDirective, DialogTitleDirective, TW_DIALOG_DATA, TW_DIALOG_DEFAULT_OPTIONS, TwDialog, TwDialogConfig, TwDialogRef, provideTwDialog };
 //# sourceMappingURL=cdevhub-ngx-tw-dialog.mjs.map