@cdevhub/ngx-tw 0.4.0 → 0.6.0

package/fesm2022/cdevhub-ngx-tw-toast-toast-renderer-BlDxemsU.mjs

@@ -0,0 +1,616 @@
+import * as i0 from '@angular/core';
+import { signal, inject, Injector, ElementRef, DestroyRef, computed, TemplateRef, untracked, ViewEncapsulation, ChangeDetectionStrategy, Component } from '@angular/core';
+import { Overlay, createGlobalPositionStrategy } from '@angular/cdk/overlay';
+import { CdkPortalOutlet, ComponentPortal } from '@angular/cdk/portal';
+import { NgTemplateOutlet } from '@angular/common';
+import { LiveAnnouncer } from '@angular/cdk/a11y';
+import { TW_TOAST_REF, TW_TOAST_DATA, ToastComponent, ToastActionDirective } from './cdevhub-ngx-tw-toast.mjs';
+
+const POSITION_AXIS = {
+    'top-right': 'right',
+    'bottom-right': 'right',
+    'top-left': 'left',
+    'bottom-left': 'left',
+    'top-center': 'top',
+    'bottom-center': 'bottom',
+};
+const POSITION_HOST_CLASSES = {
+    'top-right': 'items-end',
+    'bottom-right': 'items-end',
+    'top-left': 'items-start',
+    'bottom-left': 'items-start',
+    'top-center': 'items-center',
+    'bottom-center': 'items-center',
+};
+const POSITION_ORDER_REVERSED = {
+    'top-right': false,
+    'top-left': false,
+    'top-center': false,
+    'bottom-right': true,
+    'bottom-left': true,
+    'bottom-center': true,
+};
+const SWIPE_DISMISS_FRACTION = 0.4;
+const SWIPE_MAX_OPACITY_FADE = 0.6;
+/**
+ * Internal flex-column host rendered inside each per-position CDK overlay.
+ * Stacks visible toasts via `@for`, wires pause-on-interaction, Escape
+ * dismissal, swipe gestures, and `LiveAnnouncer` announcements.
+ *
+ * @docs-private
+ */
+class ToastContainerComponent {
+    /** Per-position stacking anchor. Mutated from {@link ToastService} via `.instance.position.set(...)`. */
+    position = signal('bottom-right', /* @ts-ignore */
+    ...(ngDevMode ? [{ debugName: "position" }] : /* istanbul ignore next */ []));
+    /** Accessible label applied to the `role="region"` host. Mutated from the service on init. */
+    regionLabel = signal('Notifications', /* @ts-ignore */
+    ...(ngDevMode ? [{ debugName: "regionLabel" }] : /* istanbul ignore next */ []));
+    /**
+     * Toasts currently assigned to this container. The service pushes toasts
+     * into this signal; the container filters by state to drive `animate.leave`.
+     */
+    visibleRefs = signal([], /* @ts-ignore */
+    ...(ngDevMode ? [{ debugName: "visibleRefs" }] : /* istanbul ignore next */ []));
+    injector = inject(Injector);
+    liveAnnouncer = inject(LiveAnnouncer);
+    host = inject((ElementRef));
+    /**
+     * Teardown for every swipe currently in flight.
+     *
+     * `swipeSessions` is a WeakMap and the listeners are bound to the toast
+     * element, so neither outlives the DOM — but a swipe interrupted by destroy
+     * (the toast auto-dismisses mid-drag) would otherwise leave the pointer
+     * capture unreleased. Each entry removes its listeners and releases capture.
+     */
+    activeSwipeTeardowns = new Set();
+    /** Per-toast handle into {@link activeSwipeTeardowns}. */
+    swipeTeardowns = new WeakMap();
+    swipeSessions = new WeakMap();
+    constructor() {
+        // A toast can auto-dismiss (or the whole container can be torn down) while
+        // a drag is still in flight, in which case `onSwipeEnd` never runs.
+        inject(DestroyRef).onDestroy(() => {
+            for (const teardown of [...this.activeSwipeTeardowns])
+                teardown();
+            this.activeSwipeTeardowns.clear();
+        });
+    }
+    entries = computed(() => {
+        const pos = this.position();
+        const axis = POSITION_AXIS[pos];
+        const enter = `toast-enter-${axis}`;
+        const leave = `toast-leave-${axis}`;
+        const refs = this.visibleRefs().filter((ref) => {
+            const s = ref.state();
+            return s === 'entering' || s === 'visible' || s === 'paused';
+        });
+        return refs.map((ref) => ({
+            ref,
+            kind: resolveKind(ref.content()),
+            enterClass: enter,
+            leaveClass: leave,
+        }));
+    }, /* @ts-ignore */
+    ...(ngDevMode ? [{ debugName: "entries" }] : /* istanbul ignore next */ []));
+    orderedEntries = computed(() => {
+        const list = this.entries();
+        return POSITION_ORDER_REVERSED[this.position()] ? [...list].reverse() : list;
+    }, /* @ts-ignore */
+    ...(ngDevMode ? [{ debugName: "orderedEntries" }] : /* istanbul ignore next */ []));
+    hostClasses = computed(() => {
+        const base = 'flex flex-col gap-2 w-full max-w-sm';
+        const align = POSITION_HOST_CLASSES[this.position()];
+        return `${base} ${align}`;
+    }, /* @ts-ignore */
+    ...(ngDevMode ? [{ debugName: "hostClasses" }] : /* istanbul ignore next */ []));
+    /** @internal Called by the service right after attaching a new toast. Runs `LiveAnnouncer`. */
+    _announceOpen(ref) {
+        const politeness = this.resolvePoliteness(ref);
+        if (politeness === 'off')
+            return;
+        const msg = this.resolveAnnouncementText(ref);
+        if (msg)
+            this.liveAnnouncer.announce(msg, politeness);
+    }
+    /** @internal Called by the service when `ref.update()` fires — re-announces with the new severity / content. */
+    _announceUpdate(ref) {
+        this._announceOpen(ref);
+    }
+    /** @internal Captures the component instance after `cdkPortalOutlet` attaches. */
+    onPortalAttached(ref, attached) {
+        if (attached && 'instance' in attached) {
+            ref.componentInstance = attached.instance;
+        }
+    }
+    /** @internal Injector factory for component-class content. Provides `TW_TOAST_DATA` + `TW_TOAST_REF`. */
+    _createContentInjector(ref) {
+        return Injector.create({
+            parent: this.injector,
+            providers: [
+                { provide: TW_TOAST_REF, useValue: ref },
+                { provide: TW_TOAST_DATA, useValue: ref.data() },
+            ],
+        });
+    }
+    // ── Template helpers ──
+    asString(content) {
+        return typeof content === 'string' ? content : '';
+    }
+    asTemplate(content) {
+        return content instanceof TemplateRef ? content : null;
+    }
+    templateContext(ref) {
+        return { $implicit: ref.data(), ref };
+    }
+    panelClassFor(ref) {
+        const raw = ref.config.panelClass;
+        if (!raw)
+            return '';
+        return Array.isArray(raw) ? raw.join(' ') : raw;
+    }
+    // ── Interaction handlers ──
+    onPointerEnter(ref) {
+        ref._setHovered(true);
+    }
+    onPointerLeave(ref) {
+        ref._setHovered(false);
+    }
+    onFocusIn(ref) {
+        ref._setFocused(true);
+    }
+    onFocusOut(ref, event) {
+        const related = event.relatedTarget;
+        const target = event.currentTarget;
+        if (related && target && target.contains(related))
+            return;
+        ref._setFocused(false);
+    }
+    onEscape(ref, event) {
+        event.stopPropagation();
+        event.preventDefault();
+        ref._dismissWith('manual');
+    }
+    onSwipeStart(ref, event, el) {
+        if (!ref.config.swipeToDismiss)
+            return;
+        if (event.button !== 0)
+            return;
+        const target = event.target;
+        if (target?.closest('button, a, input, select, textarea, [role="button"]'))
+            return;
+        const width = el.getBoundingClientRect().width;
+        this.swipeSessions.set(ref, {
+            pointerId: event.pointerId,
+            startX: event.clientX,
+            width,
+            active: false,
+        });
+        try {
+            el.setPointerCapture(event.pointerId);
+        }
+        catch {
+            // setPointerCapture throws when the pointerId is no longer active, and
+            // is absent entirely in jsdom. The swipe still tracks via the listeners
+            // below — capture is an enhancement, not a prerequisite. Matches the
+            // guards already on both `releasePointerCapture` call sites.
+        }
+        const onMove = (e) => this.onSwipeMove(ref, e, el);
+        const onUp = (e) => this.onSwipeEnd(ref, e, el, onMove, onUp);
+        el.addEventListener('pointermove', onMove);
+        el.addEventListener('pointerup', onUp);
+        el.addEventListener('pointercancel', onUp);
+        const teardown = () => {
+            el.removeEventListener('pointermove', onMove);
+            el.removeEventListener('pointerup', onUp);
+            el.removeEventListener('pointercancel', onUp);
+            try {
+                el.releasePointerCapture(event.pointerId);
+            }
+            catch {
+                /* capture already released, or the element is detached */
+            }
+            this.swipeSessions.delete(ref);
+            this.activeSwipeTeardowns.delete(teardown);
+        };
+        this.swipeTeardowns.set(ref, teardown);
+        this.activeSwipeTeardowns.add(teardown);
+    }
+    onSwipeMove(ref, event, _el) {
+        const session = this.swipeSessions.get(ref);
+        if (!session || event.pointerId !== session.pointerId)
+            return;
+        const dx = event.clientX - session.startX;
+        if (!session.active && Math.abs(dx) < 6)
+            return;
+        session.active = true;
+        ref.swipeTransform.set(`translate3d(${dx}px, 0, 0)`);
+        const fade = 1 - Math.min(Math.abs(dx) / session.width, 1) * SWIPE_MAX_OPACITY_FADE;
+        ref.swipeOpacity.set(fade);
+    }
+    onSwipeEnd(ref, event, el, onMove, onUp) {
+        const session = this.swipeSessions.get(ref);
+        el.removeEventListener('pointermove', onMove);
+        el.removeEventListener('pointerup', onUp);
+        el.removeEventListener('pointercancel', onUp);
+        const teardown = this.swipeTeardowns.get(ref);
+        if (teardown) {
+            this.activeSwipeTeardowns.delete(teardown);
+            this.swipeTeardowns.delete(ref);
+        }
+        if (!session || event.pointerId !== session.pointerId)
+            return;
+        try {
+            el.releasePointerCapture(session.pointerId);
+        }
+        catch {
+            /* no-op */
+        }
+        this.swipeSessions.delete(ref);
+        if (!session.active)
+            return;
+        const dx = event.clientX - session.startX;
+        const threshold = session.width * SWIPE_DISMISS_FRACTION;
+        const allowed = this.swipeDirectionAllowed(dx);
+        if (Math.abs(dx) >= threshold && allowed) {
+            untracked(() => {
+                ref.swipeTransform.set(`translate3d(${Math.sign(dx) * session.width * 1.2}px, 0, 0)`);
+                ref.swipeOpacity.set(0);
+                ref.leaveAnimationOverride.set('fade-out');
+            });
+            ref._dismissWith('swipe');
+        }
+        else {
+            ref.swipeTransform.set(null);
+            ref.swipeOpacity.set(null);
+        }
+    }
+    swipeDirectionAllowed(dx) {
+        const pos = this.position();
+        if (pos === 'top-right' || pos === 'bottom-right')
+            return dx > 0;
+        if (pos === 'top-left' || pos === 'bottom-left')
+            return dx < 0;
+        return true;
+    }
+    resolvePoliteness(ref) {
+        if (ref.config.politeness)
+            return ref.config.politeness;
+        return ref.severity() === 'error' ? 'assertive' : 'polite';
+    }
+    resolveAnnouncementText(ref) {
+        const explicit = ref.ariaLabel();
+        if (explicit)
+            return explicit;
+        const content = ref.content();
+        if (typeof content === 'string')
+            return content;
+        const host = this.host.nativeElement.querySelector(`[data-toast-id="${ref.id}"]`);
+        if (host)
+            return host.textContent?.trim() ?? '';
+        return this.host.nativeElement.textContent?.trim() ?? '';
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.0.7", ngImport: i0, type: ToastContainerComponent, deps: [], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.0.0", version: "22.0.7", type: ToastContainerComponent, isStandalone: true, selector: "tw-toast-container", host: { attributes: { "role": "region" }, properties: { "class": "hostClasses()", "attr.aria-label": "regionLabel()", "attr.data-position": "position()" } }, ngImport: i0, template: `
+    @for (entry of orderedEntries(); track entry.ref.id) {
+      <!--
+        Toast entry wrapper. Owns the keyboard and pointer contract for one toast.
+
+        Focus policy (SC 2.2.1 Timing Adjustable, SC 2.1.1 Keyboard):
+
+        - tabindex="0" makes the wrapper itself a tab stop. Auto-dismiss pauses on
+          focus-within, so without this a toast whose only affordances are opted
+          out (dismissible false, no action) has nothing focusable at all and a
+          keyboard-only user can never stop its 5s clock. Radix Toast puts the tab
+          stop on the toast root for the same reason.
+        - No focus trap. A toast is not modal; trapping would strand a user who
+          never asked for it.
+        - No autofocus. Moving focus on open would yank the caret out of whatever
+          the user was doing, which is worse than the delay it saves.
+        - No summon hotkey. Deliberately deferred: a document-level key would have
+          to pick one of six position containers, and the region landmark already
+          gives screen-reader users a direct route in.
+        - Escape dismisses the focused toast; the browser returns focus to the
+          document flow position on its own once the element is removed.
+
+        Pointer and focus events are forwarded to the ref so the container can
+        pause the auto-dismiss timer while the user is reading or interacting.
+      -->
+      <div
+        class="pointer-events-auto w-full max-w-sm rounded-lg focus-visible:outline-2 focus-visible:outline-offset-2 focus-visible:outline-primary-500"
+        tabindex="0"
+        [attr.data-toast-id]="entry.ref.id"
+        [style.transform]="entry.ref.swipeTransform() || null"
+        [style.opacity]="entry.ref.swipeOpacity() ?? null"
+        [style.touch-action]="'pan-y'"
+        [animate.enter]="entry.enterClass"
+        [animate.leave]="entry.ref.leaveAnimationOverride() ?? entry.leaveClass"
+        (pointerenter)="onPointerEnter(entry.ref)"
+        (pointerleave)="onPointerLeave(entry.ref)"
+        (focusin)="onFocusIn(entry.ref)"
+        (focusout)="onFocusOut(entry.ref, $event)"
+        (keydown.escape)="onEscape(entry.ref, $event)"
+        (pointerdown)="onSwipeStart(entry.ref, $event, swipeEl)"
+        #swipeEl
+      >
+        @switch (entry.kind) {
+          @case ('string') {
+            <tw-toast
+              [severity]="entry.ref.severity()"
+              [dismissible]="entry.ref.dismissible()"
+              [icon]="entry.ref.icon()"
+              [aria-label]="entry.ref.ariaLabel()"
+              [class]="panelClassFor(entry.ref)"
+              (dismissed)="entry.ref._dismissWith('manual')"
+              (actionClicked)="entry.ref.triggerAction()"
+            >
+              {{ asString(entry.ref.content()) }}
+              @if (entry.ref.action(); as action) {
+                <button twToastAction>{{ action.label }}</button>
+              }
+            </tw-toast>
+          }
+          @case ('template') {
+            <tw-toast
+              [severity]="entry.ref.severity()"
+              [dismissible]="entry.ref.dismissible()"
+              [icon]="entry.ref.icon()"
+              [aria-label]="entry.ref.ariaLabel()"
+              [class]="panelClassFor(entry.ref)"
+              (dismissed)="entry.ref._dismissWith('manual')"
+              (actionClicked)="entry.ref.triggerAction()"
+            >
+              <ng-container
+                [ngTemplateOutlet]="asTemplate(entry.ref.content())"
+                [ngTemplateOutletContext]="templateContext(entry.ref)"
+              />
+              @if (entry.ref.action(); as action) {
+                <button twToastAction>{{ action.label }}</button>
+              }
+            </tw-toast>
+          }
+          @case ('component') {
+            <ng-template
+              [cdkPortalOutlet]="entry.ref._portal"
+              (attached)="onPortalAttached(entry.ref, $event)"
+            />
+          }
+        }
+      </div>
+    }
+  `, isInline: true, dependencies: [{ kind: "directive", type: NgTemplateOutlet, selector: "[ngTemplateOutlet]", inputs: ["ngTemplateOutletContext", "ngTemplateOutlet", "ngTemplateOutletInjector"] }, { kind: "directive", type: CdkPortalOutlet, selector: "[cdkPortalOutlet]", inputs: ["cdkPortalOutlet"], outputs: ["attached"], exportAs: ["cdkPortalOutlet"] }, { kind: "component", type: ToastComponent, selector: "tw-toast", inputs: ["severity", "dismissible", "icon", "aria-label"], outputs: ["dismissed", "actionClicked"] }, { kind: "directive", type: ToastActionDirective, selector: "[twToastAction]" }], changeDetection: i0.ChangeDetectionStrategy.OnPush, encapsulation: i0.ViewEncapsulation.None });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.0.7", ngImport: i0, type: ToastContainerComponent, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'tw-toast-container',
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    encapsulation: ViewEncapsulation.None,
+                    imports: [NgTemplateOutlet, CdkPortalOutlet, ToastComponent, ToastActionDirective],
+                    host: {
+                        role: 'region',
+                        '[class]': 'hostClasses()',
+                        '[attr.aria-label]': 'regionLabel()',
+                        '[attr.data-position]': 'position()',
+                    },
+                    template: `
+    @for (entry of orderedEntries(); track entry.ref.id) {
+      <!--
+        Toast entry wrapper. Owns the keyboard and pointer contract for one toast.
+
+        Focus policy (SC 2.2.1 Timing Adjustable, SC 2.1.1 Keyboard):
+
+        - tabindex="0" makes the wrapper itself a tab stop. Auto-dismiss pauses on
+          focus-within, so without this a toast whose only affordances are opted
+          out (dismissible false, no action) has nothing focusable at all and a
+          keyboard-only user can never stop its 5s clock. Radix Toast puts the tab
+          stop on the toast root for the same reason.
+        - No focus trap. A toast is not modal; trapping would strand a user who
+          never asked for it.
+        - No autofocus. Moving focus on open would yank the caret out of whatever
+          the user was doing, which is worse than the delay it saves.
+        - No summon hotkey. Deliberately deferred: a document-level key would have
+          to pick one of six position containers, and the region landmark already
+          gives screen-reader users a direct route in.
+        - Escape dismisses the focused toast; the browser returns focus to the
+          document flow position on its own once the element is removed.
+
+        Pointer and focus events are forwarded to the ref so the container can
+        pause the auto-dismiss timer while the user is reading or interacting.
+      -->
+      <div
+        class="pointer-events-auto w-full max-w-sm rounded-lg focus-visible:outline-2 focus-visible:outline-offset-2 focus-visible:outline-primary-500"
+        tabindex="0"
+        [attr.data-toast-id]="entry.ref.id"
+        [style.transform]="entry.ref.swipeTransform() || null"
+        [style.opacity]="entry.ref.swipeOpacity() ?? null"
+        [style.touch-action]="'pan-y'"
+        [animate.enter]="entry.enterClass"
+        [animate.leave]="entry.ref.leaveAnimationOverride() ?? entry.leaveClass"
+        (pointerenter)="onPointerEnter(entry.ref)"
+        (pointerleave)="onPointerLeave(entry.ref)"
+        (focusin)="onFocusIn(entry.ref)"
+        (focusout)="onFocusOut(entry.ref, $event)"
+        (keydown.escape)="onEscape(entry.ref, $event)"
+        (pointerdown)="onSwipeStart(entry.ref, $event, swipeEl)"
+        #swipeEl
+      >
+        @switch (entry.kind) {
+          @case ('string') {
+            <tw-toast
+              [severity]="entry.ref.severity()"
+              [dismissible]="entry.ref.dismissible()"
+              [icon]="entry.ref.icon()"
+              [aria-label]="entry.ref.ariaLabel()"
+              [class]="panelClassFor(entry.ref)"
+              (dismissed)="entry.ref._dismissWith('manual')"
+              (actionClicked)="entry.ref.triggerAction()"
+            >
+              {{ asString(entry.ref.content()) }}
+              @if (entry.ref.action(); as action) {
+                <button twToastAction>{{ action.label }}</button>
+              }
+            </tw-toast>
+          }
+          @case ('template') {
+            <tw-toast
+              [severity]="entry.ref.severity()"
+              [dismissible]="entry.ref.dismissible()"
+              [icon]="entry.ref.icon()"
+              [aria-label]="entry.ref.ariaLabel()"
+              [class]="panelClassFor(entry.ref)"
+              (dismissed)="entry.ref._dismissWith('manual')"
+              (actionClicked)="entry.ref.triggerAction()"
+            >
+              <ng-container
+                [ngTemplateOutlet]="asTemplate(entry.ref.content())"
+                [ngTemplateOutletContext]="templateContext(entry.ref)"
+              />
+              @if (entry.ref.action(); as action) {
+                <button twToastAction>{{ action.label }}</button>
+              }
+            </tw-toast>
+          }
+          @case ('component') {
+            <ng-template
+              [cdkPortalOutlet]="entry.ref._portal"
+              (attached)="onPortalAttached(entry.ref, $event)"
+            />
+          }
+        }
+      </div>
+    }
+  `,
+                }]
+        }], ctorParameters: () => [] });
+function resolveKind(content) {
+    if (typeof content === 'string')
+        return 'string';
+    if (content instanceof TemplateRef)
+        return 'template';
+    return 'component';
+}
+
+const OVERLAY_EDGE_OFFSET = '1rem';
+/**
+ * Rendering half of the toast feature: owns the CDK overlays, the per-position
+ * {@link ToastContainerComponent} instances, and every `LiveAnnouncer` call.
+ *
+ * This module is reached only through a dynamic `import()` in `ToastService`,
+ * which is what keeps `@angular/cdk/overlay`, the toast components, and
+ * `tailwind-variants` out of a consumer's initial bundle. Nothing here may be
+ * imported statically from `toast.ts` — a value import (as opposed to a
+ * `import type`) would pull the whole graph back into the eager chunk and
+ * silently undo the split. See `toast.spec.ts` for the guard test.
+ *
+ * @docs-private
+ */
+class ToastRenderer {
+    injector;
+    regionAriaLabel;
+    overlay;
+    positionOverlays = new Map();
+    disposed = false;
+    constructor(injector, regionAriaLabel) {
+        this.injector = injector;
+        this.regionAriaLabel = regionAriaLabel;
+        // Resolved here rather than injected into `ToastService`, so the `Overlay`
+        // symbol lives in this lazily-loaded chunk. It is `providedIn: 'root'`, so
+        // no eager provider is required.
+        this.overlay = injector.get(Overlay);
+    }
+    /**
+     * Render a toast into its position container, creating the overlay on first
+     * use. Returns `false` if the renderer has already been disposed.
+     */
+    attach(ref, position) {
+        if (this.disposed)
+            return false;
+        const entry = this.getContainerForPosition(position);
+        const instance = entry.containerRef.instance;
+        // Component-class content needs an injector built from the container, so
+        // the portal cannot be created until the container exists.
+        const content = ref.content();
+        if (isComponentConstructor(content)) {
+            ref._portal = new ComponentPortal(content, null, instance._createContentInjector(ref));
+        }
+        instance.visibleRefs.update((list) => [...list, ref]);
+        ref._overlayPanelElement = entry.overlayRef.overlayElement;
+        return true;
+    }
+    /** Announce a freshly attached toast to assistive technology. */
+    announceOpen(ref) {
+        this.containerFor(ref)?._announceOpen(ref);
+    }
+    /** Re-announce a toast whose content or severity changed via `update()`. */
+    announceUpdate(ref) {
+        this.containerFor(ref)?._announceUpdate(ref);
+    }
+    /** Drop a dismissed toast from its container's render list. */
+    detach(ref) {
+        const instance = this.containerFor(ref);
+        if (!instance)
+            return;
+        instance.visibleRefs.update((list) => list.filter((r) => r !== ref));
+    }
+    /** Tear down every overlay this renderer created. */
+    dispose() {
+        this.disposed = true;
+        for (const { overlayRef } of this.positionOverlays.values()) {
+            overlayRef.dispose();
+        }
+        this.positionOverlays.clear();
+    }
+    containerFor(ref) {
+        return this.positionOverlays.get(ref.config.position ?? 'bottom-right')?.containerRef
+            .instance;
+    }
+    getContainerForPosition(position) {
+        const existing = this.positionOverlays.get(position);
+        if (existing)
+            return existing;
+        const overlayRef = this.overlay.create({
+            positionStrategy: this.buildPositionStrategy(position),
+            scrollStrategy: this.overlay.scrollStrategies.noop(),
+            hasBackdrop: false,
+            panelClass: ['tw-toast-overlay', `tw-toast-overlay-${position}`],
+        });
+        const containerPortal = new ComponentPortal(ToastContainerComponent, null, this.injector);
+        const containerRef = overlayRef.attach(containerPortal);
+        containerRef.instance.position.set(position);
+        containerRef.instance.regionLabel.set(this.regionAriaLabel);
+        const entry = { overlayRef, containerRef };
+        this.positionOverlays.set(position, entry);
+        return entry;
+    }
+    buildPositionStrategy(position) {
+        const strategy = createGlobalPositionStrategy(this.injector);
+        switch (position) {
+            case 'top-right':
+                strategy.top(OVERLAY_EDGE_OFFSET).right(OVERLAY_EDGE_OFFSET);
+                break;
+            case 'top-left':
+                strategy.top(OVERLAY_EDGE_OFFSET).left(OVERLAY_EDGE_OFFSET);
+                break;
+            case 'top-center':
+                strategy.top(OVERLAY_EDGE_OFFSET).centerHorizontally();
+                break;
+            case 'bottom-right':
+                strategy.bottom(OVERLAY_EDGE_OFFSET).right(OVERLAY_EDGE_OFFSET);
+                break;
+            case 'bottom-left':
+                strategy.bottom(OVERLAY_EDGE_OFFSET).left(OVERLAY_EDGE_OFFSET);
+                break;
+            case 'bottom-center':
+                strategy.bottom(OVERLAY_EDGE_OFFSET).centerHorizontally();
+                break;
+        }
+        return strategy;
+    }
+}
+function isComponentConstructor(value) {
+    return typeof value === 'function' && !(value instanceof TemplateRef);
+}
+
+export { ToastRenderer };
+//# sourceMappingURL=cdevhub-ngx-tw-toast-toast-renderer-BlDxemsU.mjs.map