ngwr 6.1.1 → 7.0.0

package/fesm2022/ngwr-window.mjs

@@ -0,0 +1,1141 @@
+import * as i0 from '@angular/core';
+import { InjectionToken, model, input, computed, output, inject, signal, afterNextRender, effect, ViewEncapsulation, Component, Injector, DestroyRef, viewChild, ViewContainerRef, runInInjectionContext, ChangeDetectionStrategy, EnvironmentInjector, PLATFORM_ID, Service } from '@angular/core';
+import { ComponentPortal } from '@angular/cdk/portal';
+import { isPlatformBrowser } from '@angular/common';
+import { WR_OVERLAY } from 'ngwr/overlay';
+import { WrStorage } from 'ngwr/storage';
+import { randomId, clamp } from 'ngwr/utils';
+import { coerceNumberProperty, coerceBooleanProperty } from '@angular/cdk/coercion';
+import { Subject } from 'rxjs';
+
+/**
+ * @license
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://github.com/thekhegay/ngwr/blob/main/LICENSE
+ */
+/** Resolves to the active `WrWindowRef` inside a programmatically-opened window's content tree. */
+const WR_WINDOW_REF = new InjectionToken('WR_WINDOW_REF');
+/** Resolves to the `data` passed in `WrWindowConfig.data`. */
+const WR_WINDOW_DATA = new InjectionToken('WR_WINDOW_DATA');
+
+/** Namespaced localStorage key for a persisted window / workspace. */
+function storageKey(cfg) {
+    const prefix = cfg.prefix ? `${cfg.prefix}:` : '';
+    return `wr:window:${prefix}${cfg.key}`;
+}
+
+/**
+ * @license
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://github.com/thekhegay/ngwr/blob/main/LICENSE
+ */
+/**
+ * Best-effort OS detection — runs once at module load. Looks at the
+ * new `navigator.userAgentData.platform` first (Chromium, no UA
+ * sniffing required), falls back to `navigator.platform` /
+ * `navigator.userAgent`. SSR-safe — returns `'windows'` when there's
+ * no `window`.
+ */
+function detectOs() {
+    if (typeof window === 'undefined' || typeof navigator === 'undefined')
+        return 'windows';
+    const uaData = navigator.userAgentData;
+    // First non-empty source — `??` alone would keep an empty platform
+    // string and skip the user-agent fallback.
+    const candidates = [uaData?.platform, navigator.platform, navigator.userAgent];
+    const platform = (candidates.find(v => !!v) ?? '').toLowerCase();
+    if (platform.includes('mac') ||
+        platform.includes('darwin') ||
+        platform.includes('iphone') ||
+        platform.includes('ipad')) {
+        return 'macos';
+    }
+    if (platform.includes('linux') || platform.includes('x11') || platform.includes('cros'))
+        return 'linux';
+    return 'windows';
+}
+const DETECTED_OS = detectOs();
+const SIZE_PRESETS = {
+    sm: { width: 320, height: 200 },
+    md: { width: 480, height: 320 },
+    lg: { width: 720, height: 480 },
+};
+const MIN_ON_VIEWPORT = 24; // keep at least this many px of the window inside the viewport
+function viewportWidth() {
+    return typeof window === 'undefined' ? 1024 : window.innerWidth;
+}
+function viewportHeight() {
+    return typeof window === 'undefined' ? 768 : window.innerHeight;
+}
+/**
+ * Internal rendering primitive for a single floating window.
+ *
+ * Not part of the public API — windows are opened through
+ * `WrWindowManager.open(Component, config)`, which portals this
+ * component for each call. Inputs map 1:1 to `WrWindowConfig`
+ * fields so the container can wire them up declaratively.
+ *
+ * @internal
+ */
+class WrWindow {
+    /** Two-way bindable visibility. `false` removes the window from the layer. */
+    open = model(true, /* @ts-ignore */
+    ...(ngDevMode ? [{ debugName: "open" }] : /* istanbul ignore next */ []));
+    /** Two-way bindable state. */
+    state = model('normal', /* @ts-ignore */
+    ...(ngDevMode ? [{ debugName: "state" }] : /* istanbul ignore next */ []));
+    /** Header title. */
+    title = input('', /* @ts-ignore */
+    ...(ngDevMode ? [{ debugName: "title" }] : /* istanbul ignore next */ []));
+    /** Auto-generated id for the title element, referenced by `aria-labelledby`. */
+    titleId = randomId('wr-window-title');
+    /** Initial position. `null` = auto-cascade from the manager. */
+    initialX = input(null, { ...(ngDevMode ? { debugName: "initialX" } : /* istanbul ignore next */ {}), transform: (v) => (v == null ? null : coerceNumberProperty(v, 0)) });
+    initialY = input(null, { ...(ngDevMode ? { debugName: "initialY" } : /* istanbul ignore next */ {}), transform: (v) => (v == null ? null : coerceNumberProperty(v, 0)) });
+    /**
+     * Size preset — seeds initial width / height when `[initialWidth]` /
+     * `[initialHeight]` are not provided. `null` keeps the explicit
+     * pixel inputs in charge. @default 'md'
+     */
+    size = input('md', /* @ts-ignore */
+    ...(ngDevMode ? [{ debugName: "size" }] : /* istanbul ignore next */ []));
+    /** Initial / forced size in pixels. Wins over `[size]` when set. */
+    initialWidth = input(null, { ...(ngDevMode ? { debugName: "initialWidth" } : /* istanbul ignore next */ {}), transform: (v) => (v == null ? null : coerceNumberProperty(v, 480)) });
+    initialHeight = input(null, { ...(ngDevMode ? { debugName: "initialHeight" } : /* istanbul ignore next */ {}), transform: (v) => (v == null ? null : coerceNumberProperty(v, 320)) });
+    /**
+     * OS chrome style. `'auto'` reads `navigator.userAgentData.platform`
+     * / `navigator.platform` and picks the matching preset (SSR-safe;
+     * unknown platforms fall back to `windows`).
+     * @default 'auto'
+     */
+    os = input('auto', /* @ts-ignore */
+    ...(ngDevMode ? [{ debugName: "os" }] : /* istanbul ignore next */ []));
+    /** Resolved OS — `auto` → detected platform. */
+    resolvedOs = computed(() => {
+        const o = this.os();
+        return o === 'auto' ? DETECTED_OS : o;
+    }, /* @ts-ignore */
+    ...(ngDevMode ? [{ debugName: "resolvedOs" }] : /* istanbul ignore next */ []));
+    /** Title-bar density. @default 'normal' */
+    chromeSize = input('normal', /* @ts-ignore */
+    ...(ngDevMode ? [{ debugName: "chromeSize" }] : /* istanbul ignore next */ []));
+    /**
+     * Enter / leave animations. Set to `false` to disable the open-fade
+     * and the minimize / maximize transitions. Honoured automatically
+     * when `prefers-reduced-motion: reduce`. @default true
+     */
+    animations = input(true, { ...(ngDevMode ? { debugName: "animations" } : /* istanbul ignore next */ {}), transform: coerceBooleanProperty });
+    minWidth = input(220, { ...(ngDevMode ? { debugName: "minWidth" } : /* istanbul ignore next */ {}), transform: (v) => coerceNumberProperty(v, 220) });
+    minHeight = input(140, { ...(ngDevMode ? { debugName: "minHeight" } : /* istanbul ignore next */ {}), transform: (v) => coerceNumberProperty(v, 140) });
+    maxWidth = input(Number.POSITIVE_INFINITY, { ...(ngDevMode ? { debugName: "maxWidth" } : /* istanbul ignore next */ {}), transform: (v) => (v == null ? Number.POSITIVE_INFINITY : coerceNumberProperty(v, Infinity)) });
+    maxHeight = input(Number.POSITIVE_INFINITY, { ...(ngDevMode ? { debugName: "maxHeight" } : /* istanbul ignore next */ {}), transform: (v) => (v == null ? Number.POSITIVE_INFINITY : coerceNumberProperty(v, Infinity)) });
+    movable = input(true, { ...(ngDevMode ? { debugName: "movable" } : /* istanbul ignore next */ {}), transform: coerceBooleanProperty });
+    resizable = input(true, { ...(ngDevMode ? { debugName: "resizable" } : /* istanbul ignore next */ {}), transform: coerceBooleanProperty });
+    keepInViewport = input(true, { ...(ngDevMode ? { debugName: "keepInViewport" } : /* istanbul ignore next */ {}), transform: coerceBooleanProperty });
+    /** Drag-to-edge snap behaviour. @default 'none' */
+    snap = input('none', /* @ts-ignore */
+    ...(ngDevMode ? [{ debugName: "snap" }] : /* istanbul ignore next */ []));
+    /**
+     * CSS selector inside the projected body that restricts the move
+     * grab — pointer-downs outside this selector won't start a drag.
+     * Use to keep interactive body content (sliders, inputs) from
+     * hijacking the title-bar drag. `null` (default) means the whole
+     * title bar is grabbable.
+     */
+    dragHandle = input(null, /* @ts-ignore */
+    ...(ngDevMode ? [{ debugName: "dragHandle" }] : /* istanbul ignore next */ []));
+    showMinimize = input(true, { ...(ngDevMode ? { debugName: "showMinimize" } : /* istanbul ignore next */ {}), transform: coerceBooleanProperty });
+    showMaximize = input(true, { ...(ngDevMode ? { debugName: "showMaximize" } : /* istanbul ignore next */ {}), transform: coerceBooleanProperty });
+    showClose = input(true, { ...(ngDevMode ? { debugName: "showClose" } : /* istanbul ignore next */ {}), transform: coerceBooleanProperty });
+    closed = output();
+    moved = output();
+    resized = output();
+    manager = inject(WrWindowManager);
+    // Position / size signals are the source of truth at runtime.
+    // Inputs (x/y/initialWidth/initialHeight) seed them in afterNextRender.
+    /** Live X (top-left). @internal */ x_ = signal(0, /* @ts-ignore */
+    ...(ngDevMode ? [{ debugName: "x_" }] : /* istanbul ignore next */ []));
+    /** Live Y (top-left). @internal */ y_ = signal(0, /* @ts-ignore */
+    ...(ngDevMode ? [{ debugName: "y_" }] : /* istanbul ignore next */ []));
+    /** Live width. @internal */ width_ = signal(0, /* @ts-ignore */
+    ...(ngDevMode ? [{ debugName: "width_" }] : /* istanbul ignore next */ []));
+    /** Live height. @internal */ height_ = signal(0, /* @ts-ignore */
+    ...(ngDevMode ? [{ debugName: "height_" }] : /* istanbul ignore next */ []));
+    // Saved geometry to restore from `maximized`.
+    restoreGeometry = null;
+    /** Stack z-index — pulled from the manager on focus. @internal */
+    z = signal(this.manager.bringToFront(), /* @ts-ignore */
+    ...(ngDevMode ? [{ debugName: "z" }] : /* istanbul ignore next */ []));
+    classes = computed(() => {
+        const parts = [
+            'wr-window',
+            `wr-window--${this.state()}`,
+            `wr-window--os-${this.resolvedOs()}`,
+            `wr-window--chrome-${this.chromeSize()}`,
+        ];
+        if (!this.open())
+            parts.push('wr-window--closed');
+        if (this.resizable() && this.state() === 'normal')
+            parts.push('wr-window--resizable');
+        if (!this.animations())
+            parts.push('wr-window--no-anim');
+        return parts.join(' ');
+    }, /* @ts-ignore */
+    ...(ngDevMode ? [{ debugName: "classes" }] : /* istanbul ignore next */ []));
+    // Effective geometry exposed to the host bindings AND to programmatic
+    // consumers (`WrWindowRef`). When maximized we ignore the live
+    // x_/y_/width_/height_ and fill the viewport instead.
+    x = computed(() => (this.state() === 'maximized' ? 0 : this.x_()), /* @ts-ignore */
+    ...(ngDevMode ? [{ debugName: "x" }] : /* istanbul ignore next */ []));
+    y = computed(() => (this.state() === 'maximized' ? 0 : this.y_()), /* @ts-ignore */
+    ...(ngDevMode ? [{ debugName: "y" }] : /* istanbul ignore next */ []));
+    width = computed(() => (this.state() === 'maximized' ? viewportWidth() : this.width_()), /* @ts-ignore */
+    ...(ngDevMode ? [{ debugName: "width" }] : /* istanbul ignore next */ []));
+    height = computed(() => this.state() === 'maximized'
+        ? viewportHeight()
+        : this.state() === 'minimized'
+            ? this.minimizedHeight()
+            : this.height_(), /* @ts-ignore */
+    ...(ngDevMode ? [{ debugName: "height" }] : /* istanbul ignore next */ []));
+    minimizedHeight = signal(40, /* @ts-ignore */
+    ...(ngDevMode ? [{ debugName: "minimizedHeight" }] : /* istanbul ignore next */ [])); // header-only height
+    /**
+     * Visible during drag when a snap target is engaged — drives the
+     * SCSS hint rendered by `WrWindowContainer` (NOT here — `.wr-window`
+     * has `overflow: hidden` which clips position-fixed descendants
+     * during the open animation while a transform is applied).
+     */
+    snapTarget = signal(null, /* @ts-ignore */
+    ...(ngDevMode ? [{ debugName: "snapTarget" }] : /* istanbul ignore next */ []));
+    constructor() {
+        afterNextRender(() => this.seedInitialGeometry());
+        // Re-clamp into viewport when window or viewport changes.
+        effect(() => {
+            if (this.state() !== 'normal')
+                return;
+            this.clampToViewport();
+        });
+    }
+    // Public API
+    close() {
+        this.open.set(false);
+        this.closed.emit();
+    }
+    minimize() {
+        this.state.set(this.state() === 'minimized' ? 'normal' : 'minimized');
+    }
+    maximize() {
+        if (this.state() === 'maximized') {
+            this.restore();
+        }
+        else {
+            this.restoreGeometry = { x: this.x_(), y: this.y_(), width: this.width_(), height: this.height_() };
+            this.state.set('maximized');
+        }
+    }
+    /** Force back to `normal` from minimized / maximized. */
+    restore() {
+        if (this.state() === 'maximized' && this.restoreGeometry) {
+            this.x_.set(this.restoreGeometry.x);
+            this.y_.set(this.restoreGeometry.y);
+            this.width_.set(this.restoreGeometry.width);
+            this.height_.set(this.restoreGeometry.height);
+            this.restoreGeometry = null;
+        }
+        this.state.set('normal');
+    }
+    /** Programmatic move — clamped to the viewport when `keepInViewport`. */
+    moveTo(x, y) {
+        this.x_.set(x);
+        this.y_.set(y);
+        this.clampToViewport();
+    }
+    /** Programmatic resize — clamped to min/max bounds. */
+    resizeTo(width, height) {
+        this.width_.set(clamp(width, this.minWidth(), this.maxWidth()));
+        this.height_.set(clamp(height, this.minHeight(), this.maxHeight()));
+        this.clampToViewport();
+    }
+    /** Re-position centered against the current viewport. */
+    center() {
+        const w = this.width_();
+        const h = this.height_();
+        this.x_.set(Math.max(0, (viewportWidth() - w) / 2));
+        this.y_.set(Math.max(0, (viewportHeight() - h) / 2));
+    }
+    /** Bring this window to the top of the stack. */
+    focus() {
+        this.z.set(this.manager.bringToFront());
+    }
+    // Host handlers
+    /** @internal — alias kept for the host `(pointerdown)` binding. */
+    focusWindow() {
+        this.focus();
+    }
+    startMove(event) {
+        if (!this.movable() || this.state() !== 'normal')
+            return;
+        const targetEl = event.target;
+        if (targetEl.closest('.wr-window__chrome-action'))
+            return;
+        const handle = this.dragHandle();
+        if (handle && !targetEl.closest(handle))
+            return;
+        event.preventDefault();
+        const target = event.currentTarget;
+        target.setPointerCapture(event.pointerId);
+        const startX = this.x_();
+        const startY = this.y_();
+        const originX = event.clientX;
+        const originY = event.clientY;
+        const move = (e) => {
+            this.x_.set(startX + (e.clientX - originX));
+            this.y_.set(startY + (e.clientY - originY));
+            this.clampToViewport();
+            this.snapTarget.set(this.detectSnapTarget(e.clientX, e.clientY));
+        };
+        const up = (e) => {
+            target.releasePointerCapture(e.pointerId);
+            target.removeEventListener('pointermove', move);
+            target.removeEventListener('pointerup', up);
+            const snap = this.snapTarget();
+            this.snapTarget.set(null);
+            if (snap) {
+                this.applySnap(snap);
+            }
+            this.moved.emit({ x: this.x_(), y: this.y_() });
+        };
+        target.addEventListener('pointermove', move);
+        target.addEventListener('pointerup', up);
+    }
+    /** Map a cursor position to a snap target, honouring `[snap]`. */
+    detectSnapTarget(clientX, clientY) {
+        const mode = this.snap();
+        if (mode === 'none')
+            return null;
+        const HOT = 12;
+        const vw = viewportWidth();
+        const vh = viewportHeight();
+        const nearLeft = clientX <= HOT;
+        const nearRight = clientX >= vw - HOT;
+        const nearTop = clientY <= HOT;
+        const nearBottom = clientY >= vh - HOT;
+        if (mode === 'all') {
+            if (nearTop && nearLeft)
+                return 'top-left';
+            if (nearTop && nearRight)
+                return 'top-right';
+            if (nearBottom && nearLeft)
+                return 'bottom-left';
+            if (nearBottom && nearRight)
+                return 'bottom-right';
+        }
+        if (nearTop)
+            return 'top'; // top edge → maximise
+        if (nearLeft)
+            return 'left';
+        if (nearRight)
+            return 'right';
+        return null;
+    }
+    /** Move + resize the window into the requested snap region. */
+    applySnap(target) {
+        const vw = viewportWidth();
+        const vh = viewportHeight();
+        const halfW = Math.floor(vw / 2);
+        const halfH = Math.floor(vh / 2);
+        switch (target) {
+            case 'top':
+                // Maximise — share state so the chrome reflects it.
+                this.restoreGeometry = { x: this.x_(), y: this.y_(), width: this.width_(), height: this.height_() };
+                this.state.set('maximized');
+                return;
+            case 'left':
+                this.x_.set(0);
+                this.y_.set(0);
+                this.width_.set(halfW);
+                this.height_.set(vh);
+                break;
+            case 'right':
+                this.x_.set(halfW);
+                this.y_.set(0);
+                this.width_.set(vw - halfW);
+                this.height_.set(vh);
+                break;
+            case 'top-left':
+                this.x_.set(0);
+                this.y_.set(0);
+                this.width_.set(halfW);
+                this.height_.set(halfH);
+                break;
+            case 'top-right':
+                this.x_.set(halfW);
+                this.y_.set(0);
+                this.width_.set(vw - halfW);
+                this.height_.set(halfH);
+                break;
+            case 'bottom-left':
+                this.x_.set(0);
+                this.y_.set(halfH);
+                this.width_.set(halfW);
+                this.height_.set(vh - halfH);
+                break;
+            case 'bottom-right':
+                this.x_.set(halfW);
+                this.y_.set(halfH);
+                this.width_.set(vw - halfW);
+                this.height_.set(vh - halfH);
+                break;
+        }
+        this.resized.emit({ width: this.width_(), height: this.height_() });
+    }
+    startResize(event, edges) {
+        if (!this.resizable() || this.state() !== 'normal')
+            return;
+        event.preventDefault();
+        event.stopPropagation();
+        const target = event.currentTarget;
+        target.setPointerCapture(event.pointerId);
+        const startX = this.x_();
+        const startY = this.y_();
+        const startW = this.width_();
+        const startH = this.height_();
+        const originX = event.clientX;
+        const originY = event.clientY;
+        const move = (e) => {
+            const dx = e.clientX - originX;
+            const dy = e.clientY - originY;
+            let nextX = startX;
+            let nextY = startY;
+            let nextW = startW;
+            let nextH = startH;
+            if (edges.r)
+                nextW = startW + dx;
+            if (edges.b)
+                nextH = startH + dy;
+            if (edges.l) {
+                nextW = startW - dx;
+                nextX = startX + dx;
+            }
+            if (edges.t) {
+                nextH = startH - dy;
+                nextY = startY + dy;
+            }
+            // Enforce min/max — when shrinking from left/top we have to fix the position too.
+            const clampedW = clamp(nextW, this.minWidth(), this.maxWidth());
+            const clampedH = clamp(nextH, this.minHeight(), this.maxHeight());
+            if (edges.l)
+                nextX += nextW - clampedW;
+            if (edges.t)
+                nextY += nextH - clampedH;
+            this.x_.set(nextX);
+            this.y_.set(nextY);
+            this.width_.set(clampedW);
+            this.height_.set(clampedH);
+            this.clampToViewport();
+        };
+        const up = (e) => {
+            target.releasePointerCapture(e.pointerId);
+            target.removeEventListener('pointermove', move);
+            target.removeEventListener('pointerup', up);
+            this.resized.emit({ width: this.width_(), height: this.height_() });
+        };
+        target.addEventListener('pointermove', move);
+        target.addEventListener('pointerup', up);
+    }
+    // Bound resize handlers for the template — avoids inline object literals
+    // re-creating on every change-detection tick.
+    resizeTL = (e) => this.startResize(e, { t: true, l: true });
+    resizeT = (e) => this.startResize(e, { t: true });
+    resizeTR = (e) => this.startResize(e, { t: true, r: true });
+    resizeR = (e) => this.startResize(e, { r: true });
+    resizeBR = (e) => this.startResize(e, { b: true, r: true });
+    resizeB = (e) => this.startResize(e, { b: true });
+    resizeBL = (e) => this.startResize(e, { b: true, l: true });
+    resizeL = (e) => this.startResize(e, { l: true });
+    // Internals
+    seedInitialGeometry() {
+        const sizePreset = this.size();
+        const preset = sizePreset ? SIZE_PRESETS[sizePreset] : SIZE_PRESETS.md;
+        const explicitW = this.initialWidth();
+        const explicitH = this.initialHeight();
+        const w = clamp(explicitW ?? preset.width, this.minWidth(), this.maxWidth());
+        const h = clamp(explicitH ?? preset.height, this.minHeight(), this.maxHeight());
+        this.width_.set(w);
+        this.height_.set(h);
+        const xIn = this.initialX();
+        const yIn = this.initialY();
+        if (xIn != null && yIn != null) {
+            this.x_.set(xIn);
+            this.y_.set(yIn);
+        }
+        else {
+            const cascade = this.manager.nextStartOffset();
+            this.x_.set(xIn ?? cascade.x);
+            this.y_.set(yIn ?? cascade.y);
+        }
+        this.clampToViewport();
+    }
+    clampToViewport() {
+        if (!this.keepInViewport())
+            return;
+        const vw = viewportWidth();
+        const vh = viewportHeight();
+        const w = this.width_();
+        this.x_.set(clamp(this.x_(), MIN_ON_VIEWPORT - w, vw - MIN_ON_VIEWPORT));
+        this.y_.set(clamp(this.y_(), 0, vh - MIN_ON_VIEWPORT));
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.0.1", ngImport: i0, type: WrWindow, deps: [], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.0.0", version: "22.0.1", type: WrWindow, isStandalone: true, selector: "wr-window", inputs: { open: { classPropertyName: "open", publicName: "open", isSignal: true, isRequired: false, transformFunction: null }, state: { classPropertyName: "state", publicName: "state", isSignal: true, isRequired: false, transformFunction: null }, title: { classPropertyName: "title", publicName: "title", isSignal: true, isRequired: false, transformFunction: null }, initialX: { classPropertyName: "initialX", publicName: "initialX", isSignal: true, isRequired: false, transformFunction: null }, initialY: { classPropertyName: "initialY", publicName: "initialY", isSignal: true, isRequired: false, transformFunction: null }, size: { classPropertyName: "size", publicName: "size", isSignal: true, isRequired: false, transformFunction: null }, initialWidth: { classPropertyName: "initialWidth", publicName: "initialWidth", isSignal: true, isRequired: false, transformFunction: null }, initialHeight: { classPropertyName: "initialHeight", publicName: "initialHeight", isSignal: true, isRequired: false, transformFunction: null }, os: { classPropertyName: "os", publicName: "os", isSignal: true, isRequired: false, transformFunction: null }, chromeSize: { classPropertyName: "chromeSize", publicName: "chromeSize", isSignal: true, isRequired: false, transformFunction: null }, animations: { classPropertyName: "animations", publicName: "animations", isSignal: true, isRequired: false, transformFunction: null }, minWidth: { classPropertyName: "minWidth", publicName: "minWidth", isSignal: true, isRequired: false, transformFunction: null }, minHeight: { classPropertyName: "minHeight", publicName: "minHeight", isSignal: true, isRequired: false, transformFunction: null }, maxWidth: { classPropertyName: "maxWidth", publicName: "maxWidth", isSignal: true, isRequired: false, transformFunction: null }, maxHeight: { classPropertyName: "maxHeight", publicName: "maxHeight", isSignal: true, isRequired: false, transformFunction: null }, movable: { classPropertyName: "movable", publicName: "movable", isSignal: true, isRequired: false, transformFunction: null }, resizable: { classPropertyName: "resizable", publicName: "resizable", isSignal: true, isRequired: false, transformFunction: null }, keepInViewport: { classPropertyName: "keepInViewport", publicName: "keepInViewport", isSignal: true, isRequired: false, transformFunction: null }, snap: { classPropertyName: "snap", publicName: "snap", isSignal: true, isRequired: false, transformFunction: null }, dragHandle: { classPropertyName: "dragHandle", publicName: "dragHandle", isSignal: true, isRequired: false, transformFunction: null }, showMinimize: { classPropertyName: "showMinimize", publicName: "showMinimize", isSignal: true, isRequired: false, transformFunction: null }, showMaximize: { classPropertyName: "showMaximize", publicName: "showMaximize", isSignal: true, isRequired: false, transformFunction: null }, showClose: { classPropertyName: "showClose", publicName: "showClose", isSignal: true, isRequired: false, transformFunction: null } }, outputs: { open: "openChange", state: "stateChange", closed: "closed", moved: "moved", resized: "resized" }, host: { attributes: { "role": "dialog" }, listeners: { "pointerdown": "focusWindow()" }, properties: { "class": "classes()", "style.left.px": "x()", "style.top.px": "y()", "style.width.px": "width()", "style.height.px": "height()", "style.z-index": "z()", "attr.aria-hidden": "!open()", "attr.aria-labelledby": "titleId" } }, ngImport: i0, template: "<div class=\"wr-window__chrome\" (pointerdown)=\"startMove($event)\" (dblclick)=\"showMaximize() && maximize()\">\n  <div class=\"wr-window__title\" [attr.id]=\"titleId\">{{ title() }}</div>\n  <div class=\"wr-window__title-extra\">\n    <ng-content select=\"[wrWindowTitleExtra]\" />\n  </div>\n\n  <div class=\"wr-window__chrome-actions\">\n    @if (resolvedOs() === 'macos') {\n      <!-- macOS-style traffic-light cluster: close \u2192 minimize \u2192 maximize.\n           Glyphs (\u00D7, \u2212, +) appear on cluster hover. -->\n      @if (showClose()) {\n        <button\n          type=\"button\"\n          class=\"wr-window__chrome-action wr-window__chrome-action--close\"\n          aria-label=\"Close\"\n          (click)=\"close()\"\n        >\n          <svg class=\"wr-window__chrome-action-glyph\" viewBox=\"0 0 10 10\" aria-hidden=\"true\">\n            <path\n              d=\"M2.2 2.2 L7.8 7.8 M7.8 2.2 L2.2 7.8\"\n              stroke=\"currentColor\"\n              stroke-width=\"1.4\"\n              stroke-linecap=\"round\"\n            />\n          </svg>\n        </button>\n      }\n      @if (showMinimize()) {\n        <button\n          type=\"button\"\n          class=\"wr-window__chrome-action wr-window__chrome-action--minimize\"\n          [attr.aria-label]=\"state() === 'minimized' ? 'Restore' : 'Minimize'\"\n          (click)=\"minimize()\"\n        >\n          <svg class=\"wr-window__chrome-action-glyph\" viewBox=\"0 0 10 10\" aria-hidden=\"true\">\n            <line x1=\"2\" y1=\"5\" x2=\"8\" y2=\"5\" stroke=\"currentColor\" stroke-width=\"1.4\" stroke-linecap=\"round\" />\n          </svg>\n        </button>\n      }\n      @if (showMaximize()) {\n        <button\n          type=\"button\"\n          class=\"wr-window__chrome-action wr-window__chrome-action--maximize\"\n          [attr.aria-label]=\"state() === 'maximized' ? 'Restore down' : 'Maximize'\"\n          (click)=\"maximize()\"\n        >\n          <svg class=\"wr-window__chrome-action-glyph\" viewBox=\"0 0 10 10\" aria-hidden=\"true\">\n            @if (state() === 'maximized') {\n              <path\n                d=\"M3 1 L1 1 L1 3 M7 1 L9 1 L9 3 M1 7 L1 9 L3 9 M9 7 L9 9 L7 9\"\n                stroke=\"currentColor\"\n                stroke-width=\"1.4\"\n                stroke-linecap=\"round\"\n                fill=\"none\"\n              />\n            } @else {\n              <path d=\"M2 5 L8 5 M5 2 L5 8\" stroke=\"currentColor\" stroke-width=\"1.4\" stroke-linecap=\"round\" />\n            }\n          </svg>\n        </button>\n      }\n    } @else {\n      <!-- Windows / Linux glyph buttons -->\n      @if (resolvedOs() !== 'linux' && showMinimize()) {\n        <button\n          type=\"button\"\n          class=\"wr-window__chrome-action wr-window__chrome-action--minimize\"\n          [attr.aria-label]=\"state() === 'minimized' ? 'Restore' : 'Minimize'\"\n          (click)=\"minimize()\"\n        >\n          <svg width=\"10\" height=\"10\" viewBox=\"0 0 10 10\" aria-hidden=\"true\">\n            <line x1=\"1\" y1=\"8\" x2=\"9\" y2=\"8\" stroke=\"currentColor\" stroke-width=\"1.5\" stroke-linecap=\"round\" />\n          </svg>\n        </button>\n      }\n\n      @if (resolvedOs() !== 'linux' && showMaximize()) {\n        <button\n          type=\"button\"\n          class=\"wr-window__chrome-action wr-window__chrome-action--maximize\"\n          [attr.aria-label]=\"state() === 'maximized' ? 'Restore down' : 'Maximize'\"\n          (click)=\"maximize()\"\n        >\n          @if (state() === 'maximized') {\n            <svg width=\"10\" height=\"10\" viewBox=\"0 0 10 10\" aria-hidden=\"true\">\n              <rect x=\"1.5\" y=\"2.5\" width=\"6\" height=\"6\" fill=\"none\" stroke=\"currentColor\" stroke-width=\"1.2\" />\n              <rect x=\"3\" y=\"1\" width=\"6\" height=\"6\" fill=\"none\" stroke=\"currentColor\" stroke-width=\"1.2\" />\n            </svg>\n          } @else {\n            <svg width=\"10\" height=\"10\" viewBox=\"0 0 10 10\" aria-hidden=\"true\">\n              <rect x=\"1\" y=\"1\" width=\"8\" height=\"8\" fill=\"none\" stroke=\"currentColor\" stroke-width=\"1.2\" />\n            </svg>\n          }\n        </button>\n      }\n\n      @if (showClose()) {\n        <button\n          type=\"button\"\n          class=\"wr-window__chrome-action wr-window__chrome-action--close\"\n          aria-label=\"Close\"\n          (click)=\"close()\"\n        >\n          <svg width=\"10\" height=\"10\" viewBox=\"0 0 10 10\" aria-hidden=\"true\">\n            <path d=\"M1 1 L9 9 M9 1 L1 9\" stroke=\"currentColor\" stroke-width=\"1.5\" stroke-linecap=\"round\" />\n          </svg>\n        </button>\n      }\n    }\n  </div>\n</div>\n\n<div class=\"wr-window__body\">\n  <ng-content />\n</div>\n\n<div class=\"wr-window__status-bar\">\n  <ng-content select=\"[wrWindowStatusBar]\" />\n</div>\n\n@if (resizable() && state() === 'normal') {\n  <span class=\"wr-window__handle wr-window__handle--t\" (pointerdown)=\"resizeT($event)\"></span>\n  <span class=\"wr-window__handle wr-window__handle--r\" (pointerdown)=\"resizeR($event)\"></span>\n  <span class=\"wr-window__handle wr-window__handle--b\" (pointerdown)=\"resizeB($event)\"></span>\n  <span class=\"wr-window__handle wr-window__handle--l\" (pointerdown)=\"resizeL($event)\"></span>\n  <span class=\"wr-window__handle wr-window__handle--tl\" (pointerdown)=\"resizeTL($event)\"></span>\n  <span class=\"wr-window__handle wr-window__handle--tr\" (pointerdown)=\"resizeTR($event)\"></span>\n  <span class=\"wr-window__handle wr-window__handle--bl\" (pointerdown)=\"resizeBL($event)\"></span>\n  <span class=\"wr-window__handle wr-window__handle--br\" (pointerdown)=\"resizeBR($event)\"></span>\n}\n", encapsulation: i0.ViewEncapsulation.None });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.0.1", ngImport: i0, type: WrWindow, decorators: [{
+            type: Component,
+            args: [{ selector: 'wr-window', encapsulation: ViewEncapsulation.None, host: {
+                        role: 'dialog',
+                        '[class]': 'classes()',
+                        '[style.left.px]': 'x()',
+                        '[style.top.px]': 'y()',
+                        '[style.width.px]': 'width()',
+                        '[style.height.px]': 'height()',
+                        '[style.z-index]': 'z()',
+                        '[attr.aria-hidden]': '!open()',
+                        '[attr.aria-labelledby]': 'titleId',
+                        '(pointerdown)': 'focusWindow()',
+                    }, template: "<div class=\"wr-window__chrome\" (pointerdown)=\"startMove($event)\" (dblclick)=\"showMaximize() && maximize()\">\n  <div class=\"wr-window__title\" [attr.id]=\"titleId\">{{ title() }}</div>\n  <div class=\"wr-window__title-extra\">\n    <ng-content select=\"[wrWindowTitleExtra]\" />\n  </div>\n\n  <div class=\"wr-window__chrome-actions\">\n    @if (resolvedOs() === 'macos') {\n      <!-- macOS-style traffic-light cluster: close \u2192 minimize \u2192 maximize.\n           Glyphs (\u00D7, \u2212, +) appear on cluster hover. -->\n      @if (showClose()) {\n        <button\n          type=\"button\"\n          class=\"wr-window__chrome-action wr-window__chrome-action--close\"\n          aria-label=\"Close\"\n          (click)=\"close()\"\n        >\n          <svg class=\"wr-window__chrome-action-glyph\" viewBox=\"0 0 10 10\" aria-hidden=\"true\">\n            <path\n              d=\"M2.2 2.2 L7.8 7.8 M7.8 2.2 L2.2 7.8\"\n              stroke=\"currentColor\"\n              stroke-width=\"1.4\"\n              stroke-linecap=\"round\"\n            />\n          </svg>\n        </button>\n      }\n      @if (showMinimize()) {\n        <button\n          type=\"button\"\n          class=\"wr-window__chrome-action wr-window__chrome-action--minimize\"\n          [attr.aria-label]=\"state() === 'minimized' ? 'Restore' : 'Minimize'\"\n          (click)=\"minimize()\"\n        >\n          <svg class=\"wr-window__chrome-action-glyph\" viewBox=\"0 0 10 10\" aria-hidden=\"true\">\n            <line x1=\"2\" y1=\"5\" x2=\"8\" y2=\"5\" stroke=\"currentColor\" stroke-width=\"1.4\" stroke-linecap=\"round\" />\n          </svg>\n        </button>\n      }\n      @if (showMaximize()) {\n        <button\n          type=\"button\"\n          class=\"wr-window__chrome-action wr-window__chrome-action--maximize\"\n          [attr.aria-label]=\"state() === 'maximized' ? 'Restore down' : 'Maximize'\"\n          (click)=\"maximize()\"\n        >\n          <svg class=\"wr-window__chrome-action-glyph\" viewBox=\"0 0 10 10\" aria-hidden=\"true\">\n            @if (state() === 'maximized') {\n              <path\n                d=\"M3 1 L1 1 L1 3 M7 1 L9 1 L9 3 M1 7 L1 9 L3 9 M9 7 L9 9 L7 9\"\n                stroke=\"currentColor\"\n                stroke-width=\"1.4\"\n                stroke-linecap=\"round\"\n                fill=\"none\"\n              />\n            } @else {\n              <path d=\"M2 5 L8 5 M5 2 L5 8\" stroke=\"currentColor\" stroke-width=\"1.4\" stroke-linecap=\"round\" />\n            }\n          </svg>\n        </button>\n      }\n    } @else {\n      <!-- Windows / Linux glyph buttons -->\n      @if (resolvedOs() !== 'linux' && showMinimize()) {\n        <button\n          type=\"button\"\n          class=\"wr-window__chrome-action wr-window__chrome-action--minimize\"\n          [attr.aria-label]=\"state() === 'minimized' ? 'Restore' : 'Minimize'\"\n          (click)=\"minimize()\"\n        >\n          <svg width=\"10\" height=\"10\" viewBox=\"0 0 10 10\" aria-hidden=\"true\">\n            <line x1=\"1\" y1=\"8\" x2=\"9\" y2=\"8\" stroke=\"currentColor\" stroke-width=\"1.5\" stroke-linecap=\"round\" />\n          </svg>\n        </button>\n      }\n\n      @if (resolvedOs() !== 'linux' && showMaximize()) {\n        <button\n          type=\"button\"\n          class=\"wr-window__chrome-action wr-window__chrome-action--maximize\"\n          [attr.aria-label]=\"state() === 'maximized' ? 'Restore down' : 'Maximize'\"\n          (click)=\"maximize()\"\n        >\n          @if (state() === 'maximized') {\n            <svg width=\"10\" height=\"10\" viewBox=\"0 0 10 10\" aria-hidden=\"true\">\n              <rect x=\"1.5\" y=\"2.5\" width=\"6\" height=\"6\" fill=\"none\" stroke=\"currentColor\" stroke-width=\"1.2\" />\n              <rect x=\"3\" y=\"1\" width=\"6\" height=\"6\" fill=\"none\" stroke=\"currentColor\" stroke-width=\"1.2\" />\n            </svg>\n          } @else {\n            <svg width=\"10\" height=\"10\" viewBox=\"0 0 10 10\" aria-hidden=\"true\">\n              <rect x=\"1\" y=\"1\" width=\"8\" height=\"8\" fill=\"none\" stroke=\"currentColor\" stroke-width=\"1.2\" />\n            </svg>\n          }\n        </button>\n      }\n\n      @if (showClose()) {\n        <button\n          type=\"button\"\n          class=\"wr-window__chrome-action wr-window__chrome-action--close\"\n          aria-label=\"Close\"\n          (click)=\"close()\"\n        >\n          <svg width=\"10\" height=\"10\" viewBox=\"0 0 10 10\" aria-hidden=\"true\">\n            <path d=\"M1 1 L9 9 M9 1 L1 9\" stroke=\"currentColor\" stroke-width=\"1.5\" stroke-linecap=\"round\" />\n          </svg>\n        </button>\n      }\n    }\n  </div>\n</div>\n\n<div class=\"wr-window__body\">\n  <ng-content />\n</div>\n\n<div class=\"wr-window__status-bar\">\n  <ng-content select=\"[wrWindowStatusBar]\" />\n</div>\n\n@if (resizable() && state() === 'normal') {\n  <span class=\"wr-window__handle wr-window__handle--t\" (pointerdown)=\"resizeT($event)\"></span>\n  <span class=\"wr-window__handle wr-window__handle--r\" (pointerdown)=\"resizeR($event)\"></span>\n  <span class=\"wr-window__handle wr-window__handle--b\" (pointerdown)=\"resizeB($event)\"></span>\n  <span class=\"wr-window__handle wr-window__handle--l\" (pointerdown)=\"resizeL($event)\"></span>\n  <span class=\"wr-window__handle wr-window__handle--tl\" (pointerdown)=\"resizeTL($event)\"></span>\n  <span class=\"wr-window__handle wr-window__handle--tr\" (pointerdown)=\"resizeTR($event)\"></span>\n  <span class=\"wr-window__handle wr-window__handle--bl\" (pointerdown)=\"resizeBL($event)\"></span>\n  <span class=\"wr-window__handle wr-window__handle--br\" (pointerdown)=\"resizeBR($event)\"></span>\n}\n" }]
+        }], ctorParameters: () => [], propDecorators: { open: [{ type: i0.Input, args: [{ isSignal: true, alias: "open", required: false }] }, { type: i0.Output, args: ["openChange"] }], state: [{ type: i0.Input, args: [{ isSignal: true, alias: "state", required: false }] }, { type: i0.Output, args: ["stateChange"] }], title: [{ type: i0.Input, args: [{ isSignal: true, alias: "title", required: false }] }], initialX: [{ type: i0.Input, args: [{ isSignal: true, alias: "initialX", required: false }] }], initialY: [{ type: i0.Input, args: [{ isSignal: true, alias: "initialY", required: false }] }], size: [{ type: i0.Input, args: [{ isSignal: true, alias: "size", required: false }] }], initialWidth: [{ type: i0.Input, args: [{ isSignal: true, alias: "initialWidth", required: false }] }], initialHeight: [{ type: i0.Input, args: [{ isSignal: true, alias: "initialHeight", required: false }] }], os: [{ type: i0.Input, args: [{ isSignal: true, alias: "os", required: false }] }], chromeSize: [{ type: i0.Input, args: [{ isSignal: true, alias: "chromeSize", required: false }] }], animations: [{ type: i0.Input, args: [{ isSignal: true, alias: "animations", required: false }] }], minWidth: [{ type: i0.Input, args: [{ isSignal: true, alias: "minWidth", required: false }] }], minHeight: [{ type: i0.Input, args: [{ isSignal: true, alias: "minHeight", required: false }] }], maxWidth: [{ type: i0.Input, args: [{ isSignal: true, alias: "maxWidth", required: false }] }], maxHeight: [{ type: i0.Input, args: [{ isSignal: true, alias: "maxHeight", required: false }] }], movable: [{ type: i0.Input, args: [{ isSignal: true, alias: "movable", required: false }] }], resizable: [{ type: i0.Input, args: [{ isSignal: true, alias: "resizable", required: false }] }], keepInViewport: [{ type: i0.Input, args: [{ isSignal: true, alias: "keepInViewport", required: false }] }], snap: [{ type: i0.Input, args: [{ isSignal: true, alias: "snap", required: false }] }], dragHandle: [{ type: i0.Input, args: [{ isSignal: true, alias: "dragHandle", required: false }] }], showMinimize: [{ type: i0.Input, args: [{ isSignal: true, alias: "showMinimize", required: false }] }], showMaximize: [{ type: i0.Input, args: [{ isSignal: true, alias: "showMaximize", required: false }] }], showClose: [{ type: i0.Input, args: [{ isSignal: true, alias: "showClose", required: false }] }], closed: [{ type: i0.Output, args: ["closed"] }], moved: [{ type: i0.Output, args: ["moved"] }], resized: [{ type: i0.Output, args: ["resized"] }] } });
+
+/** Coalesce live position/size writes — drag/resize fires every move. */
+const PERSIST_DEBOUNCE_MS = 200;
+/**
+ * Internal host attached by `WrWindowManager.open()`. Reads the config,
+ * configures a `<wr-window>`, projects the consumer's component into
+ * its body, and wires the resulting instance back to the `WrWindowRef`
+ * so consumers can drive everything imperatively.
+ *
+ * @internal
+ */
+class WrWindowContainer {
+    /** Set by the manager before view init. */
+    config;
+    /** Set by the manager before view init. */
+    ref;
+    /** Set by the manager before view init. */
+    componentType;
+    /** Custom injector with `WR_WINDOW_REF` / `WR_WINDOW_DATA` populated. */
+    childInjector;
+    hostInjector = inject(Injector);
+    storage = inject(WrStorage);
+    destroyRef = inject(DestroyRef);
+    persistTimer = null;
+    contentVcr = viewChild.required('content', { read: ViewContainerRef });
+    wrWindow = viewChild.required(WrWindow);
+    constructor() {
+        afterNextRender(() => this.attach());
+        this.destroyRef.onDestroy(() => {
+            if (this.persistTimer !== null)
+                clearTimeout(this.persistTimer);
+        });
+    }
+    attach() {
+        // 1. Create the consumer's component inside the body slot.
+        const componentRef = this.contentVcr().createComponent(this.componentType, {
+            injector: this.childInjector,
+        });
+        this.ref.componentRef = componentRef;
+        // 2. Bridge imperative actions to the underlying <wr-window>.
+        const w = this.wrWindow();
+        this.ref._doMinimize = () => w.minimize();
+        this.ref._doMaximize = () => w.maximize();
+        this.ref._doRestore = () => w.restore();
+        this.ref._doFocus = () => w.focus();
+        this.ref._doMoveTo = (x, y) => w.moveTo(x, y);
+        this.ref._doResizeTo = (width, height) => w.resizeTo(width, height);
+        this.ref._doCenter = () => w.center();
+        this.ref._doSetTitle = title => this.ref._title.set(title);
+        // 3. Sync the live geometry/state into the ref's signals so
+        //    consumers can read them reactively without poking at <wr-window>.
+        //    Angular 22 always allows signal writes inside effects — the
+        //    `allowSignalWrites` option was deprecated in this version.
+        runInInjectionContext(this.hostInjector, () => {
+            effect(() => this.ref._state.set(w.state()));
+            effect(() => this.ref._x.set(w.x()));
+            effect(() => this.ref._y.set(w.y()));
+            effect(() => this.ref._width.set(w.width()));
+            effect(() => this.ref._height.set(w.height()));
+            effect(() => this.ref._z.set(w.z()));
+        });
+        // 4. Seed the title signal from config.
+        this.ref._title.set(this.config.title ?? '');
+        // 5. Storage — hydrate from disk + auto-save on geometry change.
+        if (this.config.storage) {
+            this.hydrateFromStorage(w);
+            this.installAutosave(w);
+        }
+        // 6. Apply any state the manager pinned for restore — bridges are
+        //    now wired so `ref.minimize()` / `maximize()` actually fire.
+        const pending = this.ref.pendingStateOnMount;
+        if (pending) {
+            this.ref.pendingStateOnMount = null;
+            if (pending === 'minimized')
+                this.ref.minimize();
+            else if (pending === 'maximized')
+                this.ref.maximize();
+        }
+    }
+    /** Apply persisted geometry on top of config defaults, before the user sees the window. */
+    hydrateFromStorage(w) {
+        const cfg = this.config.storage;
+        if (!cfg)
+            return;
+        const saved = this.storage.get(storageKey(cfg));
+        if (!saved)
+            return;
+        const persist = cfg.persist ?? 'all';
+        if (persist !== 'size') {
+            if (typeof saved.x === 'number')
+                w.x_.set(saved.x);
+            if (typeof saved.y === 'number')
+                w.y_.set(saved.y);
+        }
+        if (persist !== 'position') {
+            if (typeof saved.width === 'number')
+                w.width_.set(saved.width);
+            if (typeof saved.height === 'number')
+                w.height_.set(saved.height);
+        }
+    }
+    /** Persist geometry whenever it changes, debounced. */
+    installAutosave(w) {
+        const cfg = this.config.storage;
+        if (!cfg)
+            return;
+        const persist = cfg.persist ?? 'all';
+        const key = storageKey(cfg);
+        runInInjectionContext(this.hostInjector, () => {
+            effect(() => {
+                // Read every signal we want to watch; ignore minimized/maximized
+                // overlay values — we only persist the user's chosen geometry.
+                const x = w.x_();
+                const y = w.y_();
+                const width = w.width_();
+                const height = w.height_();
+                if (this.persistTimer !== null)
+                    clearTimeout(this.persistTimer);
+                this.persistTimer = setTimeout(() => {
+                    this.persistTimer = null;
+                    const payload = {};
+                    if (persist !== 'size') {
+                        payload.x = x;
+                        payload.y = y;
+                    }
+                    if (persist !== 'position') {
+                        payload.width = width;
+                        payload.height = height;
+                    }
+                    this.storage.set(key, payload);
+                }, PERSIST_DEBOUNCE_MS);
+            });
+        });
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.0.1", ngImport: i0, type: WrWindowContainer, deps: [], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.0.0", version: "22.0.1", type: WrWindowContainer, isStandalone: true, selector: "wr-window-container", viewQueries: [{ propertyName: "contentVcr", first: true, predicate: ["content"], descendants: true, read: ViewContainerRef, isSignal: true }, { propertyName: "wrWindow", first: true, predicate: WrWindow, descendants: true, isSignal: true }], ngImport: i0, template: "<wr-window\n  [open]=\"true\"\n  [title]=\"ref.title()\"\n  [os]=\"config.os ?? 'auto'\"\n  [size]=\"config.size ?? 'md'\"\n  [chromeSize]=\"config.chromeSize ?? 'normal'\"\n  [animations]=\"config.animations ?? true\"\n  [initialX]=\"config.x ?? null\"\n  [initialY]=\"config.y ?? null\"\n  [initialWidth]=\"config.width ?? null\"\n  [initialHeight]=\"config.height ?? null\"\n  [minWidth]=\"config.minWidth ?? 220\"\n  [minHeight]=\"config.minHeight ?? 140\"\n  [maxWidth]=\"config.maxWidth ?? 1000000\"\n  [maxHeight]=\"config.maxHeight ?? 1000000\"\n  [movable]=\"config.movable ?? true\"\n  [resizable]=\"config.resizable ?? true\"\n  [keepInViewport]=\"config.keepInViewport ?? true\"\n  [snap]=\"config.snap ?? 'none'\"\n  [dragHandle]=\"config.dragHandle ?? null\"\n  [showMinimize]=\"config.showMinimize ?? true\"\n  [showMaximize]=\"config.showMaximize ?? true\"\n  [showClose]=\"config.showClose ?? true\"\n  (closed)=\"ref.close()\"\n  #window\n>\n  <ng-container #content />\n</wr-window>\n\n@if (window.snapTarget(); as target) {\n  <div class=\"wr-window__snap-hint\" [attr.data-target]=\"target\" aria-hidden=\"true\"></div>\n}\n", dependencies: [{ kind: "component", type: WrWindow, selector: "wr-window", inputs: ["open", "state", "title", "initialX", "initialY", "size", "initialWidth", "initialHeight", "os", "chromeSize", "animations", "minWidth", "minHeight", "maxWidth", "maxHeight", "movable", "resizable", "keepInViewport", "snap", "dragHandle", "showMinimize", "showMaximize", "showClose"], outputs: ["openChange", "stateChange", "closed", "moved", "resized"] }], changeDetection: i0.ChangeDetectionStrategy.OnPush, encapsulation: i0.ViewEncapsulation.None });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.0.1", ngImport: i0, type: WrWindowContainer, decorators: [{
+            type: Component,
+            args: [{ selector: 'wr-window-container', changeDetection: ChangeDetectionStrategy.OnPush, encapsulation: ViewEncapsulation.None, imports: [WrWindow], template: "<wr-window\n  [open]=\"true\"\n  [title]=\"ref.title()\"\n  [os]=\"config.os ?? 'auto'\"\n  [size]=\"config.size ?? 'md'\"\n  [chromeSize]=\"config.chromeSize ?? 'normal'\"\n  [animations]=\"config.animations ?? true\"\n  [initialX]=\"config.x ?? null\"\n  [initialY]=\"config.y ?? null\"\n  [initialWidth]=\"config.width ?? null\"\n  [initialHeight]=\"config.height ?? null\"\n  [minWidth]=\"config.minWidth ?? 220\"\n  [minHeight]=\"config.minHeight ?? 140\"\n  [maxWidth]=\"config.maxWidth ?? 1000000\"\n  [maxHeight]=\"config.maxHeight ?? 1000000\"\n  [movable]=\"config.movable ?? true\"\n  [resizable]=\"config.resizable ?? true\"\n  [keepInViewport]=\"config.keepInViewport ?? true\"\n  [snap]=\"config.snap ?? 'none'\"\n  [dragHandle]=\"config.dragHandle ?? null\"\n  [showMinimize]=\"config.showMinimize ?? true\"\n  [showMaximize]=\"config.showMaximize ?? true\"\n  [showClose]=\"config.showClose ?? true\"\n  (closed)=\"ref.close()\"\n  #window\n>\n  <ng-container #content />\n</wr-window>\n\n@if (window.snapTarget(); as target) {\n  <div class=\"wr-window__snap-hint\" [attr.data-target]=\"target\" aria-hidden=\"true\"></div>\n}\n" }]
+        }], ctorParameters: () => [], propDecorators: { contentVcr: [{ type: i0.ViewChild, args: ['content', { ...{ read: ViewContainerRef }, isSignal: true }] }], wrWindow: [{ type: i0.ViewChild, args: [i0.forwardRef(() => WrWindow), { isSignal: true }] }] } });
+
+/**
+ * @license
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://github.com/thekhegay/ngwr/blob/main/LICENSE
+ */
+/**
+ * Handle returned by `WrWindowManager.open()`.
+ *
+ * Wraps the underlying overlay, exposes signals for the live geometry,
+ * and gives the consumer programmatic control over the window
+ * (focus, move, resize, minimize, maximize, close).
+ *
+ * @example
+ * ```ts
+ * const ref = manager.open(EditorComponent, {
+ *   title: 'Untitled.md',
+ *   storage: { key: 'editor', prefix: 'app' },
+ * });
+ *
+ * ref.beforeClose(async () => {
+ *   if (!isDirty) return true;
+ *   return await confirmDiscard();
+ * });
+ *
+ * const saved = await ref.afterClosed(); // resolves with whatever the
+ *                                        // component passed to ref.close(value)
+ * ```
+ */
+class WrWindowRef {
+    _overlayRef;
+    /** Stable id — used by the taskbar, workspace save, and DI. */
+    id;
+    /** @internal — emits the close result once and completes. */
+    _closed = new Subject();
+    /** @internal — emits whenever the visual state changes. */
+    _stateChanged = new Subject();
+    /** @internal — set by the container right after attach. */
+    componentRef = null;
+    /** @internal — whether this window opts into the taskbar list. */
+    taskbarVisible = true;
+    /**
+     * @internal — non-`normal` state to apply right after the container
+     * wires its bridges (so `restoreLayout` can land a window straight
+     * into `minimized` / `maximized` even though it just opened).
+     */
+    pendingStateOnMount = null;
+    // Live geometry signals (writable internally, exposed read-only)
+    /** @internal */ _state = signal('normal', /* @ts-ignore */
+    ...(ngDevMode ? [{ debugName: "_state" }] : /* istanbul ignore next */ []));
+    /** @internal */ _x = signal(0, /* @ts-ignore */
+    ...(ngDevMode ? [{ debugName: "_x" }] : /* istanbul ignore next */ []));
+    /** @internal */ _y = signal(0, /* @ts-ignore */
+    ...(ngDevMode ? [{ debugName: "_y" }] : /* istanbul ignore next */ []));
+    /** @internal */ _width = signal(0, /* @ts-ignore */
+    ...(ngDevMode ? [{ debugName: "_width" }] : /* istanbul ignore next */ []));
+    /** @internal */ _height = signal(0, /* @ts-ignore */
+    ...(ngDevMode ? [{ debugName: "_height" }] : /* istanbul ignore next */ []));
+    /** @internal */ _z = signal(0, /* @ts-ignore */
+    ...(ngDevMode ? [{ debugName: "_z" }] : /* istanbul ignore next */ []));
+    /** @internal */ _title = signal('', /* @ts-ignore */
+    ...(ngDevMode ? [{ debugName: "_title" }] : /* istanbul ignore next */ []));
+    /** Window state. */
+    state = this._state.asReadonly();
+    /** Live X. */
+    x = this._x.asReadonly();
+    /** Live Y. */
+    y = this._y.asReadonly();
+    /** Live width. */
+    width = this._width.asReadonly();
+    /** Live height. */
+    height = this._height.asReadonly();
+    /** Stack z-index. */
+    z = this._z.asReadonly();
+    /** Live title. */
+    title = this._title.asReadonly();
+    // Hooks
+    _beforeCloseHook = null;
+    // Imperative bridges — wired by the manager / container after attach
+    /** @internal */ _doClose = null;
+    /** @internal */ _doMinimize = null;
+    /** @internal */ _doMaximize = null;
+    /** @internal */ _doRestore = null;
+    /** @internal */ _doFocus = null;
+    /** @internal */ _doMoveTo = null;
+    /** @internal */ _doResizeTo = null;
+    /** @internal */ _doCenter = null;
+    /** @internal */ _doSetTitle = null;
+    constructor(id, _overlayRef) {
+        this._overlayRef = _overlayRef;
+        this.id = id;
+    }
+    /** Resolved instance of the projected component. */
+    get componentInstance() {
+        if (!this.componentRef) {
+            throw new Error('WrWindowRef: component not yet attached');
+        }
+        return this.componentRef.instance;
+    }
+    // Lifecycle
+    /**
+     * Close the window, optionally returning a result. If a `beforeClose`
+     * hook is registered it is consulted first — a falsy resolution
+     * cancels the close.
+     */
+    async close(result) {
+        if (this._beforeCloseHook) {
+            const ok = await this._beforeCloseHook(result);
+            if (!ok)
+                return;
+        }
+        this._doClose?.(result);
+    }
+    /** Toggle the minimized state. */
+    minimize() {
+        this._doMinimize?.();
+    }
+    /** Toggle the maximized state. */
+    maximize() {
+        this._doMaximize?.();
+    }
+    /** Force-restore from minimized / maximized to `normal`. */
+    restore() {
+        this._doRestore?.();
+    }
+    /** Bring this window to the top of the stack. */
+    focus() {
+        this._doFocus?.();
+    }
+    // Programmatic geometry
+    moveTo(x, y) {
+        this._doMoveTo?.(x, y);
+    }
+    resizeTo(width, height) {
+        this._doResizeTo?.(width, height);
+    }
+    /** Re-position the window so it sits centered in the current viewport. */
+    center() {
+        this._doCenter?.();
+    }
+    setTitle(title) {
+        this._doSetTitle?.(title);
+    }
+    // Hooks
+    /**
+     * Register a guard that runs before `close()`. Return `false` (or a
+     * Promise resolving to false) to veto. Only one hook per ref —
+     * subsequent calls replace the previous.
+     */
+    beforeClose(hook) {
+        this._beforeCloseHook = hook;
+    }
+    /** Resolves with the result passed to `close()` (or `undefined`). */
+    afterClosed() {
+        return new Promise(resolve => {
+            this._closed.subscribe({
+                next: value => resolve(value),
+                complete: () => resolve(undefined),
+            });
+        });
+    }
+    /** Escape hatch — the underlying CDK overlay ref. */
+    get overlayRef() {
+        return this._overlayRef;
+    }
+}
+
+/**
+ * Owns the open `<wr-window>` stack, hands out z-indexes, cascades the
+ * default spawn position, and opens programmatic windows that wrap a
+ * consumer component.
+ *
+ * Inject the singleton and call `open(component, config)` for a
+ * dialog-style flow:
+ *
+ * ```ts
+ * const manager = inject(WrWindowManager);
+ *
+ * const ref = manager.open(EditorComponent, {
+ *   title: 'Untitled.md',
+ *   size: 'lg',
+ *   storage: { key: 'editor', prefix: 'my-app' },
+ * });
+ *
+ * const saved = await ref.afterClosed();
+ * ```
+ *
+ * Declarative `<wr-window [(open)]="...">` instances also register with
+ * the manager on focus, so both styles share the same stack ordering.
+ */
+class WrWindowManager {
+    overlay = inject(WR_OVERLAY);
+    parentInjector = inject(EnvironmentInjector);
+    storage = inject(WrStorage);
+    isBrowser = isPlatformBrowser(inject(PLATFORM_ID));
+    baseZ = 1000;
+    topZ = this.baseZ;
+    openCount = 0;
+    /** All open windows opened via `open()` — declarative `<wr-window>` is not tracked here. */
+    _windows = signal([], /* @ts-ignore */
+    ...(ngDevMode ? [{ debugName: "_windows" }] : /* istanbul ignore next */ []));
+    /**
+     * Filled by `restoreLayout` right before it invokes the consumer's
+     * opener callback. The next `open()` call with a matching `config.id`
+     * pops the entry and uses it as the initial geometry (so the seed
+     * lands at the saved coords instead of the cascade default) and
+     * applies any non-`normal` state after the bridges are wired.
+     */
+    pendingRestores = new Map();
+    /** All currently-open programmatic windows. */
+    windows = this._windows.asReadonly();
+    /** Programmatic windows that are minimized AND opted into the taskbar. */
+    minimized = computed(() => this._windows().filter(w => w.taskbarVisible && w.state() === 'minimized'), /* @ts-ignore */
+    ...(ngDevMode ? [{ debugName: "minimized" }] : /* istanbul ignore next */ []));
+    /** Reserve the next z-index. Strictly increasing across the app's lifetime. */
+    bringToFront() {
+        this.topZ += 1;
+        return this.topZ;
+    }
+    /** Cascade offset for new windows, so two opens don't perfectly overlap. */
+    nextStartOffset() {
+        const offset = (this.openCount % 10) * 30;
+        this.openCount += 1;
+        return { x: 50 + offset, y: 50 + offset };
+    }
+    /**
+     * Open a window with `component` rendered as its body. Returns a ref
+     * the caller can use to drive the window programmatically and await
+     * its result.
+     *
+     * **Singleton by id** — if `config.id` is set and a window with that
+     * id is already open, the existing ref is restored (if minimized),
+     * brought to the front, and returned. No duplicate window is
+     * created. Use this to coalesce repeated open() calls (e.g. a
+     * "Settings" menu item that should always re-focus the same window).
+     */
+    open(component, config = {}) {
+        if (config.id) {
+            const existing = this.findById(config.id);
+            if (existing) {
+                existing.restore();
+                existing.focus();
+                return existing;
+            }
+        }
+        // Honour a pending restore — `restoreLayout` populates this Map
+        // right before invoking the consumer's opener so the new window
+        // seeds at the saved geometry instead of the cascade default.
+        const pending = config.id ? this.pendingRestores.get(config.id) : undefined;
+        if (pending) {
+            this.pendingRestores.delete(config.id);
+            config = {
+                ...config,
+                x: pending.x,
+                y: pending.y,
+                width: pending.width,
+                height: pending.height,
+                title: pending.title || config.title,
+            };
+        }
+        // Each window gets its own CDK overlay pane positioned `static` —
+        // <wr-window> itself uses `position: fixed`, so the pane is only a
+        // mount point. Windows are never modal — reach for `WrDialog` when
+        // you need a backdrop + focus trap + scroll block.
+        const overlayRef = this.overlay.create({
+            positionStrategy: this.overlay.position().global(),
+            panelClass: 'wr-window-overlay',
+            hasBackdrop: false,
+        });
+        const id = config.id ?? randomId('wr-window');
+        const ref = new WrWindowRef(id, overlayRef);
+        ref.taskbarVisible = config.taskbar !== false;
+        // Provide WR_WINDOW_REF + WR_WINDOW_DATA inside the projected
+        // component's subtree so it can `inject(WR_WINDOW_REF)` etc.
+        const childInjector = Injector.create({
+            parent: this.parentInjector,
+            providers: [
+                { provide: WR_WINDOW_REF, useValue: ref },
+                { provide: WR_WINDOW_DATA, useValue: config.data ?? null },
+            ],
+        });
+        const portal = new ComponentPortal(WrWindowContainer);
+        const containerRef = overlayRef.attach(portal);
+        const container = containerRef.instance;
+        container.config = config;
+        container.ref = ref;
+        container.componentType = component;
+        container.childInjector = childInjector;
+        if (this.isBrowser) {
+            overlayRef.overlayElement.setAttribute('role', 'dialog');
+        }
+        if (config.closeOnEscape !== false) {
+            overlayRef.keydownEvents().subscribe(event => {
+                if (event.key === 'Escape') {
+                    event.preventDefault();
+                    void ref.close();
+                }
+            });
+        }
+        // Wire close → disposal + completion of the result subject. The
+        // ref's `close()` already runs the beforeClose hook before reaching
+        // this bridge.
+        ref._doClose = result => {
+            overlayRef.dispose();
+            ref._closed.next(result);
+            ref._closed.complete();
+            this._windows.update(list => list.filter(r => r !== ref));
+        };
+        this._windows.update(list => [...list, ref]);
+        // If the pending restore had a non-`normal` state, hand it to the
+        // container so it can apply it right after wiring the bridges.
+        // queueMicrotask would fire before afterNextRender — the bridges
+        // wouldn't be set yet and ref.minimize() / maximize() would no-op.
+        if (pending && pending.state !== 'normal') {
+            ref.pendingStateOnMount = pending.state;
+        }
+        return ref;
+    }
+    /** Close every programmatically-opened window. */
+    closeAll() {
+        for (const ref of [...this._windows()]) {
+            void ref.close();
+        }
+    }
+    /** Look up an open window by its `config.id`. Returns `null` when no match. */
+    findById(id) {
+        return this._windows().find(r => r.id === id) ?? null;
+    }
+    /**
+     * Drop the persisted geometry for a window so the next open uses the
+     * config defaults again. Matches `WrWindowConfig.storage` exactly.
+     */
+    clearPersistedPosition(cfg) {
+        this.storage.remove(storageKey(cfg));
+    }
+    // Workspace save/restore
+    //
+    // A workspace is a snapshot of every open window's id + state +
+    // geometry. Reopening is the consumer's job (component identities
+    // aren't serialisable), so `restoreLayout` returns the captured
+    // snapshots and a helper that re-applies geometry once the windows
+    // have been opened again.
+    /** Snapshot of one window — what `saveLayout` writes / `restoreLayout` returns. */
+    layoutKey(name) {
+        return `wr:window-layout:${name}`;
+    }
+    /**
+     * Persist the geometry + state of every open programmatic window
+     * under `name`. Pair with `restoreLayout(name)` after re-opening the
+     * matching components.
+     */
+    saveLayout(name) {
+        const snapshot = this._windows().map(ref => ({
+            id: ref.id,
+            state: ref.state(),
+            x: ref.x(),
+            y: ref.y(),
+            width: ref.width(),
+            height: ref.height(),
+            title: ref.title(),
+        }));
+        this.storage.set(this.layoutKey(name), snapshot);
+    }
+    /** Read a saved workspace. Returns `null` when no snapshot is found. */
+    readLayout(name) {
+        return this.storage.get(this.layoutKey(name));
+    }
+    /**
+     * Apply a saved workspace.
+     *
+     * Each saved entry is matched to a currently-open window by `id`. For
+     * matches, the geometry / state / title is re-applied immediately.
+     * For misses, the optional `open` callback is invoked so the consumer
+     * can re-open the right component for that id — the freshly-opened
+     * window then seeds straight to the saved geometry (no cascade flicker)
+     * and the saved state lands once the bridges are wired.
+     *
+     * ```ts
+     * manager.restoreLayout('default', (id, snap) => {
+     *   if (id.startsWith('editor:')) {
+     *     manager.open(EditorComponent, { id, title: snap.title, data: ... });
+     *   }
+     * });
+     * ```
+     */
+    restoreLayout(name, open) {
+        const snapshot = this.readLayout(name);
+        if (!snapshot)
+            return;
+        for (const snap of snapshot) {
+            const existing = this.findById(snap.id);
+            if (existing) {
+                this.applyRestore(existing, snap);
+                continue;
+            }
+            if (!open)
+                continue;
+            // Stash the geometry so the next `open()` call with this id
+            // consumes it as the seed instead of cascading.
+            this.pendingRestores.set(snap.id, snap);
+            open(snap.id, { title: snap.title });
+            // Belt + braces: if the opener didn't actually open a window (or
+            // opened with a different id), drop the stale pending entry so it
+            // doesn't ambush a future open.
+            if (!this.findById(snap.id))
+                this.pendingRestores.delete(snap.id);
+        }
+    }
+    applyRestore(ref, snap) {
+        // Force back to a known 'normal' baseline before applying state —
+        // ref.minimize() / maximize() are toggles, so this prevents a
+        // saved 'minimized' from un-minimizing an already-minimized window.
+        ref.restore();
+        if (snap.title)
+            ref.setTitle(snap.title);
+        ref.moveTo(snap.x, snap.y);
+        ref.resizeTo(snap.width, snap.height);
+        if (snap.state === 'minimized')
+            ref.minimize();
+        else if (snap.state === 'maximized')
+            ref.maximize();
+    }
+    /** Drop a saved workspace. */
+    clearLayout(name) {
+        this.storage.remove(this.layoutKey(name));
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.0.1", ngImport: i0, type: WrWindowManager, deps: [], target: i0.ɵɵFactoryTarget.Service });
+    static ɵprov = i0.ɵɵngDeclareService({ minVersion: "22.0.0", version: "22.0.1", ngImport: i0, type: WrWindowManager });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.0.1", ngImport: i0, type: WrWindowManager, decorators: [{
+            type: Service
+        }] });
+
+/**
+ * @license
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://github.com/thekhegay/ngwr/blob/main/LICENSE
+ */
+/**
+ * OS-style window taskbar. Drop one anywhere in the app — typically
+ * fixed to the bottom of the viewport — and it lists every window
+ * `WrWindowManager.open()` has handed out that's currently
+ * `minimized`. Clicking a tab restores the window; clicking the close
+ * glyph dismisses it without restoring.
+ *
+ * Windows opted out via `config.taskbar = false` never show up here.
+ *
+ * @example
+ * ```html
+ * <wr-window-taskbar />
+ * <wr-window-taskbar position="top" />
+ * ```
+ *
+ * @see https://ngwr.dev/components/window
+ */
+class WrWindowTaskbar {
+    /** Edge the taskbar pins itself to. @default 'bottom' */
+    position = input('bottom', /* @ts-ignore */
+    ...(ngDevMode ? [{ debugName: "position" }] : /* istanbul ignore next */ []));
+    manager = inject(WrWindowManager);
+    /** @internal — minimized windows that haven't opted out via `taskbar: false`. */
+    items = computed(() => this.manager.minimized(), /* @ts-ignore */
+    ...(ngDevMode ? [{ debugName: "items" }] : /* istanbul ignore next */ []));
+    classes = computed(() => `wr-window-taskbar wr-window-taskbar--${this.position()}`, /* @ts-ignore */
+    ...(ngDevMode ? [{ debugName: "classes" }] : /* istanbul ignore next */ []));
+    restore(ref) {
+        ref.restore();
+        ref.focus();
+    }
+    close(ref, event) {
+        event.stopPropagation();
+        void ref.close();
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.0.1", ngImport: i0, type: WrWindowTaskbar, deps: [], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.0.0", version: "22.0.1", type: WrWindowTaskbar, isStandalone: true, selector: "wr-window-taskbar", inputs: { position: { classPropertyName: "position", publicName: "position", isSignal: true, isRequired: false, transformFunction: null } }, host: { attributes: { "role": "toolbar", "aria-label": "Minimized windows" }, properties: { "class": "classes()" } }, ngImport: i0, template: "@if (items().length > 0) {\n  <div class=\"wr-window-taskbar__rail\">\n    @for (ref of items(); track ref.id) {\n      <button\n        type=\"button\"\n        class=\"wr-window-taskbar__tab\"\n        [attr.aria-label]=\"`Restore ${ref.title() || 'Untitled'}`\"\n        (click)=\"restore(ref)\"\n      >\n        <span class=\"wr-window-taskbar__tab-title\">{{ ref.title() || 'Untitled' }}</span>\n        <span\n          class=\"wr-window-taskbar__tab-close\"\n          role=\"button\"\n          tabindex=\"0\"\n          aria-label=\"Close window\"\n          (click)=\"close(ref, $event)\"\n          (keydown.enter)=\"close(ref, $event)\"\n        >\n          <svg width=\"9\" height=\"9\" viewBox=\"0 0 10 10\" aria-hidden=\"true\">\n            <path d=\"M1 1 L9 9 M9 1 L1 9\" stroke=\"currentColor\" stroke-width=\"1.5\" stroke-linecap=\"round\" />\n          </svg>\n        </span>\n      </button>\n    }\n  </div>\n}\n", changeDetection: i0.ChangeDetectionStrategy.OnPush, encapsulation: i0.ViewEncapsulation.None });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.0.1", ngImport: i0, type: WrWindowTaskbar, decorators: [{
+            type: Component,
+            args: [{ selector: 'wr-window-taskbar', changeDetection: ChangeDetectionStrategy.OnPush, encapsulation: ViewEncapsulation.None, host: { '[class]': 'classes()', role: 'toolbar', 'aria-label': 'Minimized windows' }, template: "@if (items().length > 0) {\n  <div class=\"wr-window-taskbar__rail\">\n    @for (ref of items(); track ref.id) {\n      <button\n        type=\"button\"\n        class=\"wr-window-taskbar__tab\"\n        [attr.aria-label]=\"`Restore ${ref.title() || 'Untitled'}`\"\n        (click)=\"restore(ref)\"\n      >\n        <span class=\"wr-window-taskbar__tab-title\">{{ ref.title() || 'Untitled' }}</span>\n        <span\n          class=\"wr-window-taskbar__tab-close\"\n          role=\"button\"\n          tabindex=\"0\"\n          aria-label=\"Close window\"\n          (click)=\"close(ref, $event)\"\n          (keydown.enter)=\"close(ref, $event)\"\n        >\n          <svg width=\"9\" height=\"9\" viewBox=\"0 0 10 10\" aria-hidden=\"true\">\n            <path d=\"M1 1 L9 9 M9 1 L1 9\" stroke=\"currentColor\" stroke-width=\"1.5\" stroke-linecap=\"round\" />\n          </svg>\n        </span>\n      </button>\n    }\n  </div>\n}\n" }]
+        }], propDecorators: { position: [{ type: i0.Input, args: [{ isSignal: true, alias: "position", required: false }] }] } });
+
+// `WrWindow` itself is NOT exported. Windows are opened through
+// `WrWindowManager.open(Component, config)` — one canonical path keeps
+// the API surface small and predictable.
+
+/**
+ * Generated bundle index. Do not edit.
+ */
+
+export { WR_WINDOW_DATA, WR_WINDOW_REF, WrWindowManager, WrWindowRef, WrWindowTaskbar };
+//# sourceMappingURL=ngwr-window.mjs.map