aril 1.2.18 → 2.0.1-dev.0

package/esm2022/boot/config/apps/src/nav.service.mjs

@@ -0,0 +1,675 @@
+import { Injectable, inject, signal } from '@angular/core';
+import { takeUntilDestroyed, toSignal } from '@angular/core/rxjs-interop';
+import { NavigationEnd, Router } from '@angular/router';
+import { MessageService } from 'primeng/api';
+import { TranslocoService } from '@ngneat/transloco';
+import { filter, map, tap } from 'rxjs/operators';
+import { RouteCloseService } from './route-close.service';
+import { safeNavigate } from './safe-navigate';
+import * as i0 from "@angular/core";
+/**
+ * Router'a verilecek URL'e `_tab` query param ekler. Tab navLink'leri CLEAN saklandığı
+ * için her navigation'da bu helper'la `_tab` eklenir. UrlSerializer serialize sırasında
+ * `_tab`'i strip eder → adres çubuğunda görünmez ama Router internal queryParams'ında
+ * kalır → strategy doğru çalışır.
+ *
+ * Path'in başında leading slash garanti edilir (Router URL formatına uygunluk için).
+ */
+function withTabId(rawNavLink, tabId) {
+    const { path, query, fragment } = splitUrl(rawNavLink ?? '');
+    const params = new URLSearchParams(query);
+    params.set('_tab', tabId);
+    return `${path}?${params.toString()}${fragment}`;
+}
+/**
+ * NavLink'i clean formatta normalize eder: leading slash garantisi, query string'ten
+ * `_tab` strip, fragment korunur. `activeRoute()` UrlSerializer override'ı sayesinde
+ * clean URL döner; tab storage da clean olmalı ki karşılaştırma çalışsın.
+ */
+function cleanNavLink(rawNavLink) {
+    const { path, query, fragment } = splitUrl(rawNavLink ?? '');
+    if (!query)
+        return path + fragment;
+    const params = new URLSearchParams(query);
+    params.delete('_tab');
+    const remaining = params.toString();
+    return remaining ? `${path}?${remaining}${fragment}` : path + fragment;
+}
+/**
+ * URL string'ini path/query/fragment olarak parçalar. Fragment (`#`) ilk önce ayrılır
+ * ki query (`?`) içindeki `#` ile karışmasın. Path'in başına leading slash garanti
+ * edilir (Router URL formatı için zorunlu).
+ *
+ * `URL` constructor'ı relative URL ile çalışmaz, manuel split `URLSearchParams`'a
+ * uygun temiz query string verir. Fragment olduğu gibi (öncesinde `#` ile) döner.
+ */
+function splitUrl(raw) {
+    const fragmentIdx = raw.indexOf('#');
+    const fragment = fragmentIdx >= 0 ? raw.slice(fragmentIdx) : '';
+    const beforeFragment = fragmentIdx >= 0 ? raw.slice(0, fragmentIdx) : raw;
+    const queryIdx = beforeFragment.indexOf('?');
+    let path = queryIdx >= 0 ? beforeFragment.slice(0, queryIdx) : beforeFragment;
+    const query = queryIdx >= 0 ? beforeFragment.slice(queryIdx + 1) : '';
+    if (!path.startsWith('/'))
+        path = '/' + path;
+    return { path, query, fragment };
+}
+/** Router'a verilen extras.state objesi — `_tab`'i history state'inde tutar. */
+function tabState(tabId) {
+    return { state: { _tab: tabId } };
+}
+/**
+ * NavLink'in remote (ilk path segment) adını döndürür. Query param'lardan ve leading
+ * slash'tan etkilenmez — `/mw/app-management?_tab=abc` → `mw`.
+ */
+function extractRemoteName(navLink) {
+    if (!navLink)
+        return null;
+    let path = navLink.split('?')[0];
+    if (path.startsWith('/'))
+        path = path.slice(1);
+    return path.split('/')[0] || null;
+}
+export class NavService {
+    constructor() {
+        this.router = inject(Router);
+        this.routeCloseService = inject(RouteCloseService);
+        this.messageService = inject(MessageService);
+        this.translocoService = inject(TranslocoService);
+        // i18n çevirileri lazy (async HTTP) yüklenir; `firstCheckForRoute`/`openHomeTab` çeviri
+        // yüklenmeden `translate('tab.home')` ederse raw key ("tab.home") kalır. Çeviri yüklenince
+        // fallback-isimli tab'ları (özellikle anasayfa) menüyle revize et → "Anasayfa" yerine oturur.
+        this.i18nReloadSub = this.translocoService.events$
+            .pipe(
+        // Yalnız root/global i18n (scope YOK) yüklenince reconcile et — 'tab.home' orada.
+        // Feature lazy scope'ları (her MFE sayfası kendi scope'unu yükler) gereksiz menü-DFS
+        // tetiklemesin; reconcile yalnız home/menü adlarının bağlı olduğu global çeviri içindir.
+        filter((e) => e.type === 'translationLoadSuccess' && !e.payload?.scope), takeUntilDestroyed())
+            .subscribe(() => this.reconcileTabsWithMenu());
+        this.firstCheckForRoute = false;
+        /**
+         * Aynı anda açık olabilecek tab sayısı tavanı. Tab bar'ın UX'i ve `CustomRouteReuseStrategy`
+         * `storedRoutes` birikimi için üst sınır. Aşılırsa yeni navigasyon engellenir.
+         */
+        this.MAX_TABS = 20;
+        /**
+         * Menu items'i NavService'ten almak için provider. `aril/boot/bridge`'i doğrudan import
+         * etmek ng-packagr'da `aril/boot/bridge → aril/boot/config/apps` döngüsü tetikliyordu
+         * (bridge `PluginMenuItem` type'ını import ediyor). Bunun yerine host shell
+         * (`AppLayoutComponent`) `setMenuItemsProvider(() => bridge.hostMenuItems())` ile bağlar.
+         * Provider yoksa label/icon resolve'u atlanır, URL segment fallback'i devreye girer.
+         */
+        this.menuItemsProvider = null;
+        /**
+         * Host shell anasayfa NavItem'ını sağlar — `AppLayoutComponent.homeNavItem` (menüdeki
+         * `root: true` öğesinden türetilir: navLink/navName/icon). Tüm tab'lar kapatıldığında
+         * liste boş kalmasın diye `openHomeTab` bunu kullanır; provider yoksa `/` + i18n fallback.
+         */
+        this.homeNavItemProvider = null;
+        /**
+         * URL adres çubuğundan görülen aktif route — `TabAwareUrlSerializer` `_tab`'i strip
+         * ettiği için bu CLEAN URL'dir (ör. `/crm/address-management/search`). Tab navLink'leri
+         * de clean saklandığı için `r.navLink === activeRoute()` doğrudan karşılaştırılır.
+         */
+        this.activeRoute = toSignal(this.router.events.pipe(filter((e) => e instanceof NavigationEnd), tap((e) => {
+            // Her NavigationEnd'de history state'ten aktif tabId'yi okuyup signal'a yaz.
+            // `extras.state` ile yapılan navigation'larda Angular history.state'e `_tab`'i koyar;
+            // browser back/forward navigasyonlarında da history.state korunur.
+            const tabIdFromState = window.history.state?.['_tab'];
+            if (typeof tabIdFromState === 'string' && tabIdFromState.length > 0) {
+                this.activeTabId.set(tabIdFromState);
+            }
+            const currentUrl = e.urlAfterRedirects || e.url;
+            // NOT: Aktif tab'ın navLink'ini güncelleme `syncActiveTabNavLinkForTab` ile
+            // `bridge.activeMFEUrl` üzerinden yapılır (kaynağa-bağlı, cross-tab safe).
+            // Tab `activeRoutes`'ta YOKSA türet: (a) ilk açılış/refresh deep-link, VEYA
+            // (b) browser back/forward ile KAPATILMIŞ tab'ın history entry'sine dönüş
+            // (kapatma host history'yi silmez → geri tuşu o URL'e gider, tab yeniden açılmalı).
+            // Bilinen tab (normal tıklama / yeni tab / açık tab'a geri) → yalnız activeTabId
+            // güncellenir (yukarıda), mevcut tab'a focus; türetme yapılmaz.
+            const knownTab = typeof tabIdFromState === 'string' &&
+                tabIdFromState.length > 0 &&
+                this.activeRoutes().some((r) => r.tabId === tabIdFromState);
+            if (!knownTab) {
+                // Refresh sonrası deep link → URL'den nav item türet ve activeRoutes'a ekle.
+                // URL'de `_tab` yoksa (UrlSerializer strip ettiği için adres çubuğundan paylaşılan
+                // link `_tab` taşımaz) yeni tabId üret + history state'e yaz; navigateByUrl
+                // çağrısı ile state injekte ederiz, adres çubuğu temiz kalır.
+                if (currentUrl) {
+                    const stateTabId = window.history.state?.['_tab'];
+                    const navLink = cleanNavLink(currentUrl);
+                    // İlk navigation'da (F5/açılış) gelen URL zaten activeRoutes'taki bir tab ile
+                    // eşleşiyorsa (özellikle restore edilmiş pinned tab) YENİ tab TÜRETME — o tab'ı
+                    // kullan. F5 sonrası Angular initial navigation `history.state._tab`'ı koruMAZ →
+                    // `knownTab` yakalayamaz; navLink eşleşmesi restore-duplicate'ini önler. Yalnız ilk
+                    // check'te + state'te `_tab` yokken: sonraki navigationlarda kasıtlı duplicate tab ve
+                    // browser-back ile kapatılan tab'ın re-derive davranışı korunur.
+                    const existing = !this.firstCheckForRoute && !stateTabId
+                        ? this.activeRoutes().find((r) => r.navLink === navLink)
+                        : undefined;
+                    let tabId = typeof stateTabId === 'string' && stateTabId.length > 0 ? stateTabId : existing?.tabId ?? '';
+                    let needsStateInject = false;
+                    if (!tabId) {
+                        tabId = this.generateTabId();
+                        needsStateInject = true;
+                    }
+                    else if (existing) {
+                        // Eşleşen tab'ın `tabId`'sini URL/state'e yansıt — adres çubuğu `_tab` taşımadığı
+                        // için RouteReuse `mfe:<remote>:<tabId>` key tutarlılığı state inject ister.
+                        needsStateInject = true;
+                    }
+                    this.activeTabId.set(tabId);
+                    if (!existing) {
+                        const menuInfo = this.resolveNavInfoFromMenu(navLink);
+                        const fallbackName = () => {
+                            let path = navLink;
+                            if (path.startsWith('/'))
+                                path = path.slice(1);
+                            const parts = path.split('/').filter((s) => s.length > 0);
+                            const last = parts[parts.length - 1] || 'Page';
+                            return last.charAt(0).toUpperCase() + last.slice(1).replace(/-/g, ' ');
+                        };
+                        this.addToActiveRoutes({
+                            tabId,
+                            navLink,
+                            navName: menuInfo?.navName || fallbackName(),
+                            icon: menuInfo?.icon
+                        });
+                    }
+                    if (needsStateInject) {
+                        // Mevcut navigation cycle bitiminden SONRA yeni navigation tetikle —
+                        // `queueMicrotask` Router'ın navigation kuyruğu finalize olmadan çalışıp
+                        // `AbortError: Transition was skipped`'a yol açıyordu. `setTimeout(0)` macrotask
+                        // ile current cycle biter, Router idle olur. `this.navigate` zaten AbortError'ı
+                        // yutuyor — concurrent navigation race'leri sessizce iptal edilir.
+                        setTimeout(() => {
+                            safeNavigate(this.router, withTabId(navLink, tabId), {
+                                replaceUrl: true,
+                                state: { _tab: tabId }
+                            }).catch(() => { });
+                        }, 0);
+                    }
+                }
+                this.firstCheckForRoute = true;
+            }
+        }), map((w) => w.urlAfterRedirects || w.url)));
+        this.activeRoutes = signal([]);
+        /** History state'ten okunan aktif tab kimliği — `isActive(tab) = tab.tabId === activeTabId()`. */
+        this.activeTabId = signal('');
+    }
+    /** RFC4122 v4 UUID — collision-free, internal state taşımaz. */
+    generateTabId() {
+        return crypto.randomUUID();
+    }
+    setMenuItemsProvider(provider) {
+        this.menuItemsProvider = provider;
+        // Provider geç set edildiyse (örn. shell layout NavigationEnd'den sonra mount oldu),
+        // activeRoutes'ta default/fallback isimle eklenmiş ilk tab'ı menüyle revize et.
+        this.reconcileTabsWithMenu();
+    }
+    setHomeNavItemProvider(provider) {
+        this.homeNavItemProvider = provider;
+        // Refresh/ilk açılış path'inde fallback ("Page") isim/ikonla eklenmiş anasayfa tab'ı
+        // varsa, provider hazır olunca menüyle (home dahil) revize et.
+        this.reconcileTabsWithMenu();
+    }
+    /**
+     * Chrome bookmark click davranışı: aktif tab'ın navLink/navName'i güncellenir,
+     * o tab'a navigate edilir. Yeni tab açılmaz. Mevcut tab'ın `tabId`'si KORUNUR —
+     * Router'a `?_tab=tabId` ile navigate edilir, history state'e yazılır; navLink
+     * storage'da CLEAN saklanır.
+     */
+    navigateInCurrentTab(navItem) {
+        const idx = this.findActiveTabIndex();
+        if (idx === -1) {
+            // Aktif tab yok — fallback olarak yeni tab aç.
+            this.openInNewTabAndFocus(navItem);
+            return;
+        }
+        const existingTab = this.activeRoutes()[idx];
+        const tabId = existingTab.tabId;
+        const newNavLink = cleanNavLink(navItem.navLink);
+        // Aynı navLink'e tıklama → yine de navigate et (`onSameUrlNavigation: 'reload'`).
+        if (existingTab.navLink === newNavLink) {
+            safeNavigate(this.router, withTabId(newNavLink, tabId), tabState(tabId));
+            return;
+        }
+        this.activeRoutes.update((routes) => {
+            const next = [...routes];
+            // Mevcut tab'ın `tabId` VE `pinned` durumu korunur — menüden gelen navItem `pinned`
+            // taşımaz; `{ ...navItem }` ile ezilirse sabitlenmiş tab unpin olurdu (tab içeriğini
+            // değiştirmek sabitlemeyi bozmamalı).
+            next[idx] = { ...navItem, tabId, navLink: newNavLink, pinned: existingTab.pinned };
+            return next;
+        });
+        safeNavigate(this.router, withTabId(newNavLink, tabId), tabState(tabId));
+    }
+    /**
+     * Arka planda yeni tab aç — aktif tab değişmez, navigate edilmez. `tabId` her zaman
+     * yeni üretilir (ya da caller verdiyse o kullanılır), exists check YOKTUR; aynı path
+     * birden fazla tab'da bağımsız yaşayabilir.
+     */
+    openInBackgroundTab(navItem) {
+        if (this.activeRoutes().length >= this.MAX_TABS) {
+            this.notifyMaxTabsReached();
+            return;
+        }
+        const tabId = navItem.tabId || this.generateTabId();
+        const navLink = cleanNavLink(navItem.navLink);
+        this.activeRoutes.update((val) => [...val, { ...navItem, tabId, navLink }]);
+    }
+    /**
+     * Yeni tab aç ve o tab'a geç. Exists check YOK — aynı path'in iki ayrı tab'i kabul edilir;
+     * her tab kendi `tabId`'siyle ayrı componentRef instantiate eder.
+     */
+    openInNewTabAndFocus(navItem) {
+        if (this.activeRoutes().length >= this.MAX_TABS) {
+            this.notifyMaxTabsReached();
+            return;
+        }
+        const tabId = navItem.tabId || this.generateTabId();
+        const navLink = cleanNavLink(navItem.navLink);
+        this.activeRoutes.update((val) => [...val, { ...navItem, tabId, navLink }]);
+        safeNavigate(this.router, withTabId(navLink, tabId), tabState(tabId));
+    }
+    /** Programatik tab ekleme; activeRoute observable refresh path'i bunu kullanır. */
+    addToActiveRoutes(navItem) {
+        if (this.activeRoutes().length >= this.MAX_TABS) {
+            // Programmatic çağrı — toast göstermek yerine sessizce return.
+            return;
+        }
+        const tabId = navItem.tabId || this.generateTabId();
+        const navLink = cleanNavLink(navItem.navLink);
+        // Signal change detection reference identity ile çalışır — yeni array dön.
+        this.activeRoutes.update((val) => [...val, { ...navItem, tabId, navLink }]);
+    }
+    /**
+     * Aktif tab'ı `activeTabId` üzerinden bulur. Aynı `navLink`'in birden fazla tab'i
+     * olabileceği için navLink karşılaştırması ambiguous; tabId tek doğru kimlik.
+     */
+    findActiveTabIndex() {
+        const tabId = this.activeTabId();
+        if (!tabId)
+            return -1;
+        return this.activeRoutes().findIndex((r) => r.tabId === tabId);
+    }
+    /** Tab limiti aşıldığında kullanıcıyı toast ile bilgilendirir. */
+    notifyMaxTabsReached() {
+        this.messageService.add({
+            severity: 'warn',
+            summary: this.translocoService.translate('tab.maxReachedSummary', { max: this.MAX_TABS }),
+            detail: this.translocoService.translate('tab.maxReachedDetail'),
+            key: 'toast-root'
+        });
+    }
+    /** Anasayfa navLink'i — host menü root item'ından (yoksa '/'), clean format. */
+    homeNavLink() {
+        return cleanNavLink(this.homeNavItemProvider?.().navLink || '/');
+    }
+    /** Verilen tab anasayfaya mı ait. */
+    isHomeTab(item) {
+        return item.navLink === this.homeNavLink();
+    }
+    /**
+     * Anasayfa tab'ı açıp ona navigate eder — tab listesi HİÇ boş kalmamalı (en az 1 tab).
+     * NavItem host menü root item'ından gelir; yoksa `/` + i18n fallback ('tab.home', 'pi pi-home').
+     */
+    openHomeTab() {
+        const base = this.homeNavItemProvider?.();
+        const navLink = cleanNavLink(base?.navLink || '/');
+        const tabId = this.generateTabId();
+        const home = {
+            tabId,
+            navLink,
+            navName: base?.navName || this.translocoService.translate('tab.home'),
+            icon: base?.icon || 'pi pi-home'
+        };
+        this.activeRoutes.update((val) => [...val, home]);
+        return safeNavigate(this.router, withTabId(navLink, tabId), tabState(tabId));
+    }
+    closeNavigation(navItem) {
+        // `tabId` ile bul — aynı path'in birden fazla tab'i olabileceği için `navLink`
+        // karşılaştırması ambiguous olur, kimlik bazlı arama tek doğru yöntem.
+        const idx = this.activeRoutes().findIndex((r) => r.tabId === navItem.tabId);
+        console.log(`[NavService] closeNavigation tabId="${navItem.tabId}" navLink="${navItem.navLink}" index=${idx}`);
+        if (idx === -1)
+            return;
+        const closedItem = this.activeRoutes()[idx];
+        // Son kalan tab anasayfaysa kapatma — her zaman en az 1 (anasayfa) tab açık kalmalı.
+        if (this.activeRoutes().length === 1 && this.isHomeTab(closedItem))
+            return;
+        // Signal change detection reference identity ile çalışır — yeni array dön.
+        this.activeRoutes.update((val) => val.filter((_, i) => i !== idx));
+        const cleanup = () => this.cleanupTabHandle(closedItem);
+        const closingActiveTab = this.activeTabId() === closedItem.tabId;
+        if (closingActiveTab) {
+            // Aktif tab kapatılıyor — başka tab'a (veya home'a) navigate edip cleanup'ı SONRA tetikle.
+            // Aksi takdirde strategy henüz `store('mfe:${remoteName}:${tabId}', handle)`'i yapmadan
+            // `deleteStoredRoute` çağrılır ve cleanup boş hit eder; ardından detach tamamlanınca
+            // element hidden container'da orphan kalır (race condition).
+            const remaining = this.activeRoutes();
+            const willNavigateItem = remaining.length > 0 ? remaining[idx] || remaining[idx - 1] : null;
+            if (willNavigateItem) {
+                safeNavigate(this.router, withTabId(willNavigateItem.navLink, willNavigateItem.tabId), tabState(willNavigateItem.tabId)).finally(cleanup);
+            }
+            else {
+                // Hiç tab kalmadı — boş bırakma, anasayfa tab'ı aç (en az 1 tab kuralı).
+                this.openHomeTab().finally(cleanup);
+            }
+        }
+        else {
+            // Aktif değildi — navigation gerekmez. Ancak arka planda açılıp (`openInBackgroundTab`)
+            // hiç görüntülenmemiş tab henüz Router tarafından `store()` edilmemiş olabilir; cleanup'ı
+            // bir microtask geciktirip olası store cycle'ına fırsat veriyoruz (orphan handle önlemi).
+            void Promise.resolve().then(cleanup);
+        }
+    }
+    /**
+     * Bir tab hariç diğer tüm tab'ları kapatır. Aktif tab kapatılanlardan ise `keepItem`'a geçer.
+     * **Sabit tab'lar korunur** (Chrome davranışı) — pinned olanlar her zaman açık kalır.
+     */
+    closeOthers(keepItem) {
+        const all = this.activeRoutes();
+        const toClose = all.filter((r) => r.tabId !== keepItem.tabId && !r.pinned);
+        if (toClose.length === 0)
+            return;
+        const survivorIds = new Set([keepItem.tabId, ...all.filter((r) => r.pinned).map((r) => r.tabId)]);
+        this.activeRoutes.set(all.filter((r) => survivorIds.has(r.tabId)));
+        const cleanupAll = () => toClose.forEach((t) => this.cleanupTabHandle(t));
+        if (this.activeTabId() !== keepItem.tabId) {
+            safeNavigate(this.router, withTabId(keepItem.navLink, keepItem.tabId), tabState(keepItem.tabId)).finally(cleanupAll);
+        }
+        else {
+            cleanupAll();
+        }
+    }
+    /**
+     * Verilen tab'ın sağındaki tüm tab'ları kapatır. **Sabit tab'lar korunur** —
+     * pinned bir tab sağda olsa bile kapatılmaz (Chrome davranışı).
+     */
+    closeToRight(item) {
+        const all = this.activeRoutes();
+        const idx = all.findIndex((r) => r.tabId === item.tabId);
+        if (idx === -1)
+            return;
+        const toClose = all.slice(idx + 1).filter((r) => !r.pinned);
+        if (toClose.length === 0)
+            return;
+        const toCloseIds = new Set(toClose.map((r) => r.tabId));
+        this.activeRoutes.set(all.filter((r) => !toCloseIds.has(r.tabId)));
+        const activeWasClosed = toClose.some((r) => r.tabId === this.activeTabId());
+        const cleanupAll = () => toClose.forEach((t) => this.cleanupTabHandle(t));
+        if (activeWasClosed) {
+            safeNavigate(this.router, withTabId(item.navLink, item.tabId), tabState(item.tabId)).finally(cleanupAll);
+        }
+        else {
+            cleanupAll();
+        }
+    }
+    /**
+     * Sabit olmayan tüm tab'ları kapatır. **Sabit tab'lar korunur** — kullanıcı "Tümünü Kapat"
+     * isterse bile pinned tab'lar açık kalır (Chrome davranışı). Hiç pinned tab yoksa ana sayfaya
+     * navigate edilir.
+     */
+    closeAll() {
+        const all = this.activeRoutes();
+        if (all.length === 0)
+            return;
+        const toClose = all.filter((r) => !r.pinned);
+        if (toClose.length === 0)
+            return;
+        const survivors = all.filter((r) => r.pinned);
+        this.activeRoutes.set(survivors);
+        const cleanupAll = () => toClose.forEach((t) => this.cleanupTabHandle(t));
+        // Aktif tab kapatılanlardan ise: ya bir pinned tab'a geç (yaşıyorsa), yoksa ana sayfaya.
+        const activeWasClosed = toClose.some((r) => r.tabId === this.activeTabId());
+        if (activeWasClosed) {
+            if (survivors.length > 0) {
+                const target = survivors[0];
+                safeNavigate(this.router, withTabId(target.navLink, target.tabId), tabState(target.tabId)).finally(cleanupAll);
+            }
+            else {
+                // Pinned survivor yok — boş bırakma, anasayfa tab'ı aç (en az 1 tab kuralı).
+                this.openHomeTab().finally(cleanupAll);
+            }
+        }
+        else {
+            cleanupAll();
+        }
+    }
+    /**
+     * Tab sabitleme toggle — Chrome-vari pinning. Pinned tab'lar tab bar'ın **soluna** taşınır
+     * (insertion sırasını koruyarak), kompakt görünür, `closeOthers`/`closeToRight`/`closeAll`
+     * çağrılarından korunur. Aynı pinned tıklanırsa sabitlemeyi kaldırır → normal alanın **sonuna**
+     * taşınır.
+     */
+    togglePin(item) {
+        const all = this.activeRoutes();
+        const idx = all.findIndex((r) => r.tabId === item.tabId);
+        if (idx === -1)
+            return;
+        const target = all[idx];
+        const newPinned = !target.pinned;
+        // Önce target'ı array'den çıkar, sonra pinned/normal bloğunun **sonuna** ekle.
+        // Bu Chrome davranışı: pinlenince pinned bloğun sonuna (en sağa), unpinlenince normal
+        // bloğun başına (pinned'in hemen sağına).
+        const without = all.filter((_, i) => i !== idx);
+        const pinnedSegment = without.filter((r) => r.pinned);
+        const normalSegment = without.filter((r) => !r.pinned);
+        const updated = { ...target, pinned: newPinned };
+        // Pin → pinned bloğun sonuna; unpin → normal bloğun başına. Her iki durumda da `updated`,
+        // pinned ve normal segmentlerin SINIRINA yerleşir (pozisyon aynı) → tek ifade yeterli.
+        const next = [...pinnedSegment, updated, ...normalSegment];
+        this.activeRoutes.set(next);
+    }
+    /** Sıradaki tab'a (circular) geçer. */
+    goToNextTab() {
+        const all = this.activeRoutes();
+        if (all.length === 0)
+            return;
+        const idx = this.findActiveTabIndex();
+        const nextIdx = idx === -1 ? 0 : (idx + 1) % all.length;
+        const target = all[nextIdx];
+        safeNavigate(this.router, withTabId(target.navLink, target.tabId), tabState(target.tabId));
+    }
+    /** Önceki tab'a (circular) geçer. */
+    goToPrevTab() {
+        const all = this.activeRoutes();
+        if (all.length === 0)
+            return;
+        const idx = this.findActiveTabIndex();
+        const prevIdx = idx === -1 ? all.length - 1 : (idx - 1 + all.length) % all.length;
+        const target = all[prevIdx];
+        safeNavigate(this.router, withTabId(target.navLink, target.tabId), tabState(target.tabId));
+    }
+    /** Index'teki tab'a geçer (Alt+1..9 için 0-tabanlı index). */
+    goToTabByIndex(index) {
+        const all = this.activeRoutes();
+        if (index < 0 || index >= all.length)
+            return;
+        const target = all[index];
+        safeNavigate(this.router, withTabId(target.navLink, target.tabId), tabState(target.tabId));
+    }
+    /**
+     * Verilen tab'a navigate — UI'dan (tab tıklama) çağrılır. Router'a `_tab` ile URL ve
+     * `extras.state` ile tabId verir; UrlSerializer adres çubuğunu temiz tutar.
+     */
+    navigateToTab(item) {
+        if (!item?.navLink || !item?.tabId)
+            return;
+        const url = withTabId(item.navLink, item.tabId);
+        console.log(`[NavService] navigateToTab tabId="${item.tabId}" navLink="${item.navLink}" → url="${url}"`);
+        safeNavigate(this.router, url, tabState(item.tabId));
+    }
+    /**
+     * Belirli bir tab'ın `navLink`'ini ve (varsa) `navName`'ini günceller. **Kaynağa-bağlı**
+     * (per-tab) sync — caller hangi tab'ın URL'i olduğunu söyler, NavService aktif tab
+     * varsayımında bulunmaz. Hidden container'daki async MFE NavigationEnd'leri aktif tab'ın
+     * state'ini KONTAMİNE EDEMEZ.
+     *
+     * `title` parametresi MFE Router deepest route'unun `Route.title` veya `data.tabName`
+     * değerinden gelir → kullanıcı detail/edit gibi sub-sayfalara navigate olduğunda tab
+     * adı dinamik güncellenir. `title` undefined ise tab.navName değişmez (statik kalır).
+     *
+     * AppLayoutComponent effect'ten `bridge.activeMFEUrl` (`{tabId, url, title}`) ile çağrılır.
+     */
+    syncActiveTabNavLinkForTab(tabId, rawUrl, title) {
+        if (!tabId || !rawUrl)
+            return;
+        const cleanUrl = cleanNavLink(rawUrl);
+        const target = this.activeRoutes().find((t) => t.tabId === tabId);
+        if (!target)
+            return;
+        const linkChanged = target.navLink !== cleanUrl;
+        const nameChanged = !!title && target.navName !== title;
+        if (!linkChanged && !nameChanged)
+            return;
+        const newNavLink = linkChanged ? cleanUrl : target.navLink;
+        const newName = nameChanged ? title : target.navName;
+        console.log(`[NavService] syncActiveTabNavLinkForTab tab="${tabId}" ` +
+            `navLink "${target.navLink}" → "${newNavLink}" name "${target.navName}" → "${newName}"`);
+        this.activeRoutes.update((routes) => routes.map((t) => (t.tabId === tabId ? { ...t, navLink: newNavLink, navName: newName } : t)));
+    }
+    /**
+     * Tab context-menu "Yinele" (Chrome "Duplicate"): mevcut tab'ın path'i kopyalanır, yeni bir
+     * `tabId` üretilir ve yeni tab oluşturulur. Strategy `_tab` query param'ını route key'in
+     * parçası yaptığı için yeni tab bağımsız `storedRoutes` slot'una yazılır → bağımsız
+     * componentRef + state. Mevcut tab korunur, kullanıcı her ikisinde de bağımsız çalışabilir.
+     */
+    duplicateTab(item) {
+        if (!item?.navLink)
+            return;
+        if (this.activeRoutes().length >= this.MAX_TABS) {
+            this.notifyMaxTabsReached();
+            return;
+        }
+        const newTabId = this.generateTabId();
+        const newNavLink = cleanNavLink(item.navLink);
+        this.activeRoutes.update((val) => [
+            ...val,
+            { ...item, tabId: newTabId, navLink: newNavLink }
+        ]);
+        safeNavigate(this.router, withTabId(newNavLink, newTabId), tabState(newTabId));
+    }
+    reorderActiveRoutes(newRoutes) {
+        // Pinned/normal sınırı koruması — sabit tab'lar tab bar'ın solunda (insertion sırasıyla),
+        // normal tab'lar sağında kalır. CDK drag drop bir tab'ı yanlış segmente düşürürse
+        // burada otomatik düzeltilir. Segment içi sıra korunur.
+        const pinned = newRoutes.filter((r) => r.pinned);
+        const normal = newRoutes.filter((r) => !r.pinned);
+        this.activeRoutes.set([...pinned, ...normal]);
+    }
+    /**
+     * Menu config'inden navLink'e karşılık gelen item'i longest-prefix match ile bulup
+     * aktif dilde label + icon döner. Adres çubuğuna URL yapıştırarak deep link açıldığında
+     * tab'ın menüden açılan tab'la aynı görünüme sahip olmasını sağlar.
+     *
+     * Lookup `menuItemsProvider` üzerinden — host shell `setMenuItemsProvider` ile
+     * `bridge.hostMenuItems()`'a bağlar. Provider yoksa veya eşleşme yoksa `null` döner ve
+     * caller URL segment fallback'ine düşer.
+     */
+    resolveNavInfoFromMenu(navLink) {
+        // Anasayfa (menüdeki `root` öğesi) çoğu zaman `routerLink` ile eşleşmez (routerLink'i `/`
+        // veya boş olabilir, longest-prefix match'e takılmaz) → `/` için fallback "Page" + jenerik
+        // ikon dönerdi. Home provider varsa ad/ikonu doğrudan oradan (root item'dan) çöz.
+        if (this.homeNavItemProvider) {
+            const home = this.homeNavItemProvider();
+            // Anasayfa navLink eşleşiyorsa dön — menü boş/geç yüklendiyse ya da menüde `root` öğesi
+            // yoksa navName/icon boş gelebilir; i18n ('tab.home') + ev ikonu fallback ile asla
+            // menü-segment fallback'ine ("Page") düşme.
+            if (navLink === cleanNavLink(home.navLink || '/')) {
+                return {
+                    navName: home.navName || this.translocoService.translate('tab.home'),
+                    icon: home.icon || 'pi pi-home'
+                };
+            }
+        }
+        const items = this.menuItemsProvider?.();
+        if (!items?.length)
+            return null;
+        const path = navLink.split('?')[0];
+        const matched = this.findMenuItemForRoute(items, path);
+        if (!matched)
+            return null;
+        const lang = this.translocoService.getActiveLang();
+        const label = matched.label;
+        const navName = label?.[lang] || label?.['tr'] || label?.['en'] || '';
+        if (!navName)
+            return null;
+        return { navName, icon: matched.icon };
+    }
+    /**
+     * Menü/i18n yüklenince tab'ları (özellikle anasayfa) menüyle revize eder — refresh/ilk açılış
+     * path'inde tab fallback isim/iconla eklenmiş olabilir (menü veya çeviri o anda hazır değildi).
+     * Tetikleyiciler: `setMenuItemsProvider`/`setHomeNavItemProvider`, `translationLoadSuccess`
+     * event'i ve host shell menü signal'i değişimi (`AppLayoutComponent` effect). Public — host
+     * layout menü async yüklenince çağırır ki anasayfa adı `tab.home` fallback'inde takılmasın.
+     */
+    reconcileTabsWithMenu() {
+        const tabs = this.activeRoutes();
+        if (!tabs.length)
+            return;
+        let changed = false;
+        const next = tabs.map((t) => {
+            const info = this.resolveNavInfoFromMenu(t.navLink);
+            if (!info)
+                return t;
+            if (t.navName === info.navName && t.icon === info.icon)
+                return t;
+            changed = true;
+            return { ...t, navName: info.navName, icon: info.icon };
+        });
+        if (changed)
+            this.activeRoutes.set(next);
+    }
+    /**
+     * Menu ağacında verilen path için en spesifik (longest routerLink prefix) eşleşmeyi bulur.
+     * `mw/app-management/view-app` için hem `mw` hem `mw/app-management/view-app` eşleşse,
+     * daha uzun olan kazanır → leaf menu item'ın label/icon'u kullanılır.
+     *
+     * Path leading slash içerebilir (Router URL formatı), menu config routerLink'leri
+     * genelde leading slash'sız (`mw/meters`); ikisini normalize edip karşılaştırırız.
+     */
+    findMenuItemForRoute(items, path) {
+        const normalize = (p) => (p.startsWith('/') ? p.slice(1) : p);
+        const normalizedPath = normalize(path);
+        let best;
+        const visit = (list) => {
+            for (const it of list) {
+                if (it.routerLink) {
+                    const r = normalize(it.routerLink);
+                    if (r && (normalizedPath === r || normalizedPath.startsWith(r + '/'))) {
+                        const length = r.length;
+                        if (!best || length > best.length)
+                            best = { length, item: it };
+                    }
+                }
+                if (it.items?.length)
+                    visit(it.items);
+            }
+        };
+        visit(items);
+        return best?.item;
+    }
+    /**
+     * Bir tab'ın stored route handle'ını strategy'den temizler. Key formatı
+     * `mfe:${remoteName}:${tabId}` — strategy `processCleanupKey` matcher key'inden hem
+     * MFE custom element handle'ını hem o tab'a ait child route handle'larını düşürür.
+     */
+    cleanupTabHandle(item) {
+        const remoteName = extractRemoteName(item.navLink);
+        if (!remoteName || !item.tabId)
+            return;
+        console.log(`[NavService] cleanupTabHandle remoteName="${remoteName}" tabId="${item.tabId}"`);
+        this.routeCloseService.deleteStoredRoute(`mfe:${remoteName}:${item.tabId}`);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.1.2", ngImport: i0, type: NavService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.1.2", ngImport: i0, type: NavService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.1.2", ngImport: i0, type: NavService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"nav.service.js","sourceRoot":"","sources":["../../../../../../projects/aril/boot/config/apps/src/nav.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable, inject, signal } from '@angular/core';\r\nimport { takeUntilDestroyed, toSignal } from '@angular/core/rxjs-interop';\r\nimport { NavigationEnd, Router } from '@angular/router';\r\n\r\nimport { MessageService } from 'primeng/api';\r\n\r\nimport { TranslocoService } from '@ngneat/transloco';\r\nimport { filter, map, tap } from 'rxjs/operators';\r\n\r\nimport { PluginMenuItem } from './interfaces';\r\nimport { RouteCloseService } from './route-close.service';\r\nimport { safeNavigate } from './safe-navigate';\r\n\r\n/**\r\n * `tabId` her tab'ı tekil kılan kimliktir; aynı `navLink` (path) altında birden fazla\r\n * bağımsız tab açılabilmesini sağlar. NavService Router'a navigation yaparken URL'e\r\n * `_tab=<tabId>` query param ekler ve `extras.state._tab` ile history state'e yazar.\r\n * `TabAwareUrlSerializer` adres çubuğundan `_tab`'i strip eder; Router internal\r\n * `queryParams` korunur → `CustomRouteReuseStrategy.getRouteKey` doğru tab key türetir.\r\n *\r\n * **Önemli**: `NavItem.navLink` HER ZAMAN CLEAN URL (no `_tab`). Hem display hem\r\n * `activeRoute()` ile karşılaştırma için kullanılır. Tab kimliği `tabId` üzerinden\r\n * yönetilir (`activeTabId` signal).\r\n */\r\nexport interface NavItem {\r\n\ttabId: string;\r\n\tnavLink: string;\r\n\tnavName: string;\r\n\t/**\r\n\t * Menu item'dan gelen icon class'ı (örn. 'pi pi-bolt'). Verilmezse layout `getTabIcon`\r\n\t * menu config'inden longest-prefix match ile lookup yapar; o da bulamazsa generic ikona düşer.\r\n\t */\r\n\ticon?: string;\r\n\t/**\r\n\t * Tab sabitleme — Chrome-vari pinning. Sabit tab'lar tab bar'ın **soluna** sıralanır,\r\n\t * kompakt gösterilir (yalnız icon, başlık + close button gizli), `closeOthers`/`closeToRight`/\r\n\t * `closeAll` çağrılarından korunur. Drag & drop'ta pinned ↔ normal sınırı geçilemez.\r\n\t */\r\n\tpinned?: boolean;\r\n}\r\n\r\n/**\r\n * Router'a verilecek URL'e `_tab` query param ekler. Tab navLink'leri CLEAN saklandığı\r\n * için her navigation'da bu helper'la `_tab` eklenir. UrlSerializer serialize sırasında\r\n * `_tab`'i strip eder → adres çubuğunda görünmez ama Router internal queryParams'ında\r\n * kalır → strategy doğru çalışır.\r\n *\r\n * Path'in başında leading slash garanti edilir (Router URL formatına uygunluk için).\r\n */\r\nfunction withTabId(rawNavLink: string, tabId: string): string {\r\n\tconst { path, query, fragment } = splitUrl(rawNavLink ?? '');\r\n\tconst params = new URLSearchParams(query);\r\n\tparams.set('_tab', tabId);\r\n\treturn `${path}?${params.toString()}${fragment}`;\r\n}\r\n\r\n/**\r\n * NavLink'i clean formatta normalize eder: leading slash garantisi, query string'ten\r\n * `_tab` strip, fragment korunur. `activeRoute()` UrlSerializer override'ı sayesinde\r\n * clean URL döner; tab storage da clean olmalı ki karşılaştırma çalışsın.\r\n */\r\nfunction cleanNavLink(rawNavLink: string): string {\r\n\tconst { path, query, fragment } = splitUrl(rawNavLink ?? '');\r\n\tif (!query) return path + fragment;\r\n\tconst params = new URLSearchParams(query);\r\n\tparams.delete('_tab');\r\n\tconst remaining = params.toString();\r\n\treturn remaining ? `${path}?${remaining}${fragment}` : path + fragment;\r\n}\r\n\r\n/**\r\n * URL string'ini path/query/fragment olarak parçalar. Fragment (`#`) ilk önce ayrılır\r\n * ki query (`?`) içindeki `#` ile karışmasın. Path'in başına leading slash garanti\r\n * edilir (Router URL formatı için zorunlu).\r\n *\r\n * `URL` constructor'ı relative URL ile çalışmaz, manuel split `URLSearchParams`'a\r\n * uygun temiz query string verir. Fragment olduğu gibi (öncesinde `#` ile) döner.\r\n */\r\nfunction splitUrl(raw: string): { path: string; query: string; fragment: string } {\r\n\tconst fragmentIdx = raw.indexOf('#');\r\n\tconst fragment = fragmentIdx >= 0 ? raw.slice(fragmentIdx) : '';\r\n\tconst beforeFragment = fragmentIdx >= 0 ? raw.slice(0, fragmentIdx) : raw;\r\n\tconst queryIdx = beforeFragment.indexOf('?');\r\n\tlet path = queryIdx >= 0 ? beforeFragment.slice(0, queryIdx) : beforeFragment;\r\n\tconst query = queryIdx >= 0 ? beforeFragment.slice(queryIdx + 1) : '';\r\n\tif (!path.startsWith('/')) path = '/' + path;\r\n\treturn { path, query, fragment };\r\n}\r\n\r\n/** Router'a verilen extras.state objesi — `_tab`'i history state'inde tutar. */\r\nfunction tabState(tabId: string): { state: Record<string, unknown> } {\r\n\treturn { state: { _tab: tabId } };\r\n}\r\n\r\n/**\r\n * NavLink'in remote (ilk path segment) adını döndürür. Query param'lardan ve leading\r\n * slash'tan etkilenmez — `/mw/app-management?_tab=abc` → `mw`.\r\n */\r\nfunction extractRemoteName(navLink: string | undefined): string | null {\r\n\tif (!navLink) return null;\r\n\tlet path = navLink.split('?')[0];\r\n\tif (path.startsWith('/')) path = path.slice(1);\r\n\treturn path.split('/')[0] || null;\r\n}\r\n\r\n@Injectable({\r\n\tprovidedIn: 'root'\r\n})\r\nexport class NavService {\r\n\trouter: Router = inject(Router);\r\n\trouteCloseService: RouteCloseService = inject(RouteCloseService);\r\n\tprivate readonly messageService: MessageService = inject(MessageService);\r\n\tprivate readonly translocoService: TranslocoService = inject(TranslocoService);\r\n\r\n\t// i18n çevirileri lazy (async HTTP) yüklenir; `firstCheckForRoute`/`openHomeTab` çeviri\r\n\t// yüklenmeden `translate('tab.home')` ederse raw key (\"tab.home\") kalır. Çeviri yüklenince\r\n\t// fallback-isimli tab'ları (özellikle anasayfa) menüyle revize et → \"Anasayfa\" yerine oturur.\r\n\tprivate readonly i18nReloadSub = this.translocoService.events$\r\n\t\t.pipe(\r\n\t\t\t// Yalnız root/global i18n (scope YOK) yüklenince reconcile et — 'tab.home' orada.\r\n\t\t\t// Feature lazy scope'ları (her MFE sayfası kendi scope'unu yükler) gereksiz menü-DFS\r\n\t\t\t// tetiklemesin; reconcile yalnız home/menü adlarının bağlı olduğu global çeviri içindir.\r\n\t\t\tfilter((e) => e.type === 'translationLoadSuccess' && !e.payload?.scope),\r\n\t\t\ttakeUntilDestroyed()\r\n\t\t)\r\n\t\t.subscribe(() => this.reconcileTabsWithMenu());\r\n\r\n\tfirstCheckForRoute = false;\r\n\t/**\r\n\t * Aynı anda açık olabilecek tab sayısı tavanı. Tab bar'ın UX'i ve `CustomRouteReuseStrategy`\r\n\t * `storedRoutes` birikimi için üst sınır. Aşılırsa yeni navigasyon engellenir.\r\n\t */\r\n\tprivate readonly MAX_TABS = 20;\r\n\r\n\t/** RFC4122 v4 UUID — collision-free, internal state taşımaz. */\r\n\tprivate generateTabId(): string {\r\n\t\treturn crypto.randomUUID();\r\n\t}\r\n\r\n\t/**\r\n\t * Menu items'i NavService'ten almak için provider. `aril/boot/bridge`'i doğrudan import\r\n\t * etmek ng-packagr'da `aril/boot/bridge → aril/boot/config/apps` döngüsü tetikliyordu\r\n\t * (bridge `PluginMenuItem` type'ını import ediyor). Bunun yerine host shell\r\n\t * (`AppLayoutComponent`) `setMenuItemsProvider(() => bridge.hostMenuItems())` ile bağlar.\r\n\t * Provider yoksa label/icon resolve'u atlanır, URL segment fallback'i devreye girer.\r\n\t */\r\n\tprivate menuItemsProvider: (() => PluginMenuItem[]) | null = null;\r\n\tsetMenuItemsProvider(provider: () => PluginMenuItem[]): void {\r\n\t\tthis.menuItemsProvider = provider;\r\n\t\t// Provider geç set edildiyse (örn. shell layout NavigationEnd'den sonra mount oldu),\r\n\t\t// activeRoutes'ta default/fallback isimle eklenmiş ilk tab'ı menüyle revize et.\r\n\t\tthis.reconcileTabsWithMenu();\r\n\t}\r\n\r\n\t/**\r\n\t * Host shell anasayfa NavItem'ını sağlar — `AppLayoutComponent.homeNavItem` (menüdeki\r\n\t * `root: true` öğesinden türetilir: navLink/navName/icon). Tüm tab'lar kapatıldığında\r\n\t * liste boş kalmasın diye `openHomeTab` bunu kullanır; provider yoksa `/` + i18n fallback.\r\n\t */\r\n\tprivate homeNavItemProvider: (() => NavItem) | null = null;\r\n\tsetHomeNavItemProvider(provider: () => NavItem): void {\r\n\t\tthis.homeNavItemProvider = provider;\r\n\t\t// Refresh/ilk açılış path'inde fallback (\"Page\") isim/ikonla eklenmiş anasayfa tab'ı\r\n\t\t// varsa, provider hazır olunca menüyle (home dahil) revize et.\r\n\t\tthis.reconcileTabsWithMenu();\r\n\t}\r\n\r\n\t/**\r\n\t * URL adres çubuğundan görülen aktif route — `TabAwareUrlSerializer` `_tab`'i strip\r\n\t * ettiği için bu CLEAN URL'dir (ör. `/crm/address-management/search`). Tab navLink'leri\r\n\t * de clean saklandığı için `r.navLink === activeRoute()` doğrudan karşılaştırılır.\r\n\t */\r\n\tactiveRoute = toSignal<string>(\r\n\t\tthis.router.events.pipe(\r\n\t\t\tfilter((e) => e instanceof NavigationEnd),\r\n\t\t\ttap((e) => {\r\n\t\t\t\t// Her NavigationEnd'de history state'ten aktif tabId'yi okuyup signal'a yaz.\r\n\t\t\t\t// `extras.state` ile yapılan navigation'larda Angular history.state'e `_tab`'i koyar;\r\n\t\t\t\t// browser back/forward navigasyonlarında da history.state korunur.\r\n\t\t\t\tconst tabIdFromState = (window.history.state as Record<string, unknown> | null)?.['_tab'];\r\n\t\t\t\tif (typeof tabIdFromState === 'string' && tabIdFromState.length > 0) {\r\n\t\t\t\t\tthis.activeTabId.set(tabIdFromState);\r\n\t\t\t\t}\r\n\r\n\t\t\t\tconst currentUrl = (e as NavigationEnd).urlAfterRedirects || (e as NavigationEnd).url;\r\n\r\n\t\t\t\t// NOT: Aktif tab'ın navLink'ini güncelleme `syncActiveTabNavLinkForTab` ile\r\n\t\t\t\t// `bridge.activeMFEUrl` üzerinden yapılır (kaynağa-bağlı, cross-tab safe).\r\n\r\n\t\t\t\t// Tab `activeRoutes`'ta YOKSA türet: (a) ilk açılış/refresh deep-link, VEYA\r\n\t\t\t\t// (b) browser back/forward ile KAPATILMIŞ tab'ın history entry'sine dönüş\r\n\t\t\t\t// (kapatma host history'yi silmez → geri tuşu o URL'e gider, tab yeniden açılmalı).\r\n\t\t\t\t// Bilinen tab (normal tıklama / yeni tab / açık tab'a geri) → yalnız activeTabId\r\n\t\t\t\t// güncellenir (yukarıda), mevcut tab'a focus; türetme yapılmaz.\r\n\t\t\t\tconst knownTab =\r\n\t\t\t\t\ttypeof tabIdFromState === 'string' &&\r\n\t\t\t\t\ttabIdFromState.length > 0 &&\r\n\t\t\t\t\tthis.activeRoutes().some((r) => r.tabId === tabIdFromState);\r\n\t\t\t\tif (!knownTab) {\r\n\t\t\t\t\t// Refresh sonrası deep link → URL'den nav item türet ve activeRoutes'a ekle.\r\n\t\t\t\t\t// URL'de `_tab` yoksa (UrlSerializer strip ettiği için adres çubuğundan paylaşılan\r\n\t\t\t\t\t// link `_tab` taşımaz) yeni tabId üret + history state'e yaz; navigateByUrl\r\n\t\t\t\t\t// çağrısı ile state injekte ederiz, adres çubuğu temiz kalır.\r\n\t\t\t\t\tif (currentUrl) {\r\n\t\t\t\t\t\tconst stateTabId = (window.history.state as Record<string, unknown> | null)?.['_tab'];\r\n\t\t\t\t\t\tconst navLink = cleanNavLink(currentUrl);\r\n\t\t\t\t\t\t// İlk navigation'da (F5/açılış) gelen URL zaten activeRoutes'taki bir tab ile\r\n\t\t\t\t\t\t// eşleşiyorsa (özellikle restore edilmiş pinned tab) YENİ tab TÜRETME — o tab'ı\r\n\t\t\t\t\t\t// kullan. F5 sonrası Angular initial navigation `history.state._tab`'ı koruMAZ →\r\n\t\t\t\t\t\t// `knownTab` yakalayamaz; navLink eşleşmesi restore-duplicate'ini önler. Yalnız ilk\r\n\t\t\t\t\t\t// check'te + state'te `_tab` yokken: sonraki navigationlarda kasıtlı duplicate tab ve\r\n\t\t\t\t\t\t// browser-back ile kapatılan tab'ın re-derive davranışı korunur.\r\n\t\t\t\t\t\tconst existing =\r\n\t\t\t\t\t\t\t!this.firstCheckForRoute && !stateTabId\r\n\t\t\t\t\t\t\t\t? this.activeRoutes().find((r) => r.navLink === navLink)\r\n\t\t\t\t\t\t\t\t: undefined;\r\n\t\t\t\t\t\tlet tabId =\r\n\t\t\t\t\t\t\ttypeof stateTabId === 'string' && stateTabId.length > 0 ? stateTabId : existing?.tabId ?? '';\r\n\t\t\t\t\t\tlet needsStateInject = false;\r\n\t\t\t\t\t\tif (!tabId) {\r\n\t\t\t\t\t\t\ttabId = this.generateTabId();\r\n\t\t\t\t\t\t\tneedsStateInject = true;\r\n\t\t\t\t\t\t} else if (existing) {\r\n\t\t\t\t\t\t\t// Eşleşen tab'ın `tabId`'sini URL/state'e yansıt — adres çubuğu `_tab` taşımadığı\r\n\t\t\t\t\t\t\t// için RouteReuse `mfe:<remote>:<tabId>` key tutarlılığı state inject ister.\r\n\t\t\t\t\t\t\tneedsStateInject = true;\r\n\t\t\t\t\t\t}\r\n\t\t\t\t\t\tthis.activeTabId.set(tabId);\r\n\t\t\t\t\t\tif (!existing) {\r\n\t\t\t\t\t\t\tconst menuInfo = this.resolveNavInfoFromMenu(navLink);\r\n\t\t\t\t\t\t\tconst fallbackName = (): string => {\r\n\t\t\t\t\t\t\t\tlet path = navLink;\r\n\t\t\t\t\t\t\t\tif (path.startsWith('/')) path = path.slice(1);\r\n\t\t\t\t\t\t\t\tconst parts = path.split('/').filter((s) => s.length > 0);\r\n\t\t\t\t\t\t\t\tconst last = parts[parts.length - 1] || 'Page';\r\n\t\t\t\t\t\t\t\treturn last.charAt(0).toUpperCase() + last.slice(1).replace(/-/g, ' ');\r\n\t\t\t\t\t\t\t};\r\n\t\t\t\t\t\t\tthis.addToActiveRoutes({\r\n\t\t\t\t\t\t\t\ttabId,\r\n\t\t\t\t\t\t\t\tnavLink,\r\n\t\t\t\t\t\t\t\tnavName: menuInfo?.navName || fallbackName(),\r\n\t\t\t\t\t\t\t\ticon: menuInfo?.icon\r\n\t\t\t\t\t\t\t});\r\n\t\t\t\t\t\t}\r\n\t\t\t\t\t\tif (needsStateInject) {\r\n\t\t\t\t\t\t\t// Mevcut navigation cycle bitiminden SONRA yeni navigation tetikle —\r\n\t\t\t\t\t\t\t// `queueMicrotask` Router'ın navigation kuyruğu finalize olmadan çalışıp\r\n\t\t\t\t\t\t\t// `AbortError: Transition was skipped`'a yol açıyordu. `setTimeout(0)` macrotask\r\n\t\t\t\t\t\t\t// ile current cycle biter, Router idle olur. `this.navigate` zaten AbortError'ı\r\n\t\t\t\t\t\t\t// yutuyor — concurrent navigation race'leri sessizce iptal edilir.\r\n\t\t\t\t\t\t\tsetTimeout(() => {\r\n\t\t\t\t\t\t\t\tsafeNavigate(this.router, withTabId(navLink, tabId), {\r\n\t\t\t\t\t\t\t\t\treplaceUrl: true,\r\n\t\t\t\t\t\t\t\t\tstate: { _tab: tabId }\r\n\t\t\t\t\t\t\t\t}).catch(() => {/* refresh-path noise: caller yok, silent */});\r\n\t\t\t\t\t\t\t}, 0);\r\n\t\t\t\t\t\t}\r\n\t\t\t\t\t}\r\n\t\t\t\t\tthis.firstCheckForRoute = true;\r\n\t\t\t\t}\r\n\t\t\t}),\r\n\t\t\tmap((w) => (w as NavigationEnd).urlAfterRedirects || (w as NavigationEnd).url)\r\n\t\t)\r\n\t);\r\n\r\n\tactiveRoutes = signal<NavItem[]>([]);\r\n\t/** History state'ten okunan aktif tab kimliği — `isActive(tab) = tab.tabId === activeTabId()`. */\r\n\tactiveTabId = signal<string>('');\r\n\r\n\t/**\r\n\t * Chrome bookmark click davranışı: aktif tab'ın navLink/navName'i güncellenir,\r\n\t * o tab'a navigate edilir. Yeni tab açılmaz. Mevcut tab'ın `tabId`'si KORUNUR —\r\n\t * Router'a `?_tab=tabId` ile navigate edilir, history state'e yazılır; navLink\r\n\t * storage'da CLEAN saklanır.\r\n\t */\r\n\tnavigateInCurrentTab(navItem: NavItem): void {\r\n\t\tconst idx = this.findActiveTabIndex();\r\n\t\tif (idx === -1) {\r\n\t\t\t// Aktif tab yok — fallback olarak yeni tab aç.\r\n\t\t\tthis.openInNewTabAndFocus(navItem);\r\n\t\t\treturn;\r\n\t\t}\r\n\t\tconst existingTab = this.activeRoutes()[idx];\r\n\t\tconst tabId = existingTab.tabId;\r\n\t\tconst newNavLink = cleanNavLink(navItem.navLink);\r\n\t\t// Aynı navLink'e tıklama → yine de navigate et (`onSameUrlNavigation: 'reload'`).\r\n\t\tif (existingTab.navLink === newNavLink) {\r\n\t\t\tsafeNavigate(this.router, withTabId(newNavLink, tabId), tabState(tabId));\r\n\t\t\treturn;\r\n\t\t}\r\n\t\tthis.activeRoutes.update((routes) => {\r\n\t\t\tconst next = [...routes];\r\n\t\t\t// Mevcut tab'ın `tabId` VE `pinned` durumu korunur — menüden gelen navItem `pinned`\r\n\t\t\t// taşımaz; `{ ...navItem }` ile ezilirse sabitlenmiş tab unpin olurdu (tab içeriğini\r\n\t\t\t// değiştirmek sabitlemeyi bozmamalı).\r\n\t\t\tnext[idx] = { ...navItem, tabId, navLink: newNavLink, pinned: existingTab.pinned };\r\n\t\t\treturn next;\r\n\t\t});\r\n\t\tsafeNavigate(this.router, withTabId(newNavLink, tabId), tabState(tabId));\r\n\t}\r\n\r\n\t/**\r\n\t * Arka planda yeni tab aç — aktif tab değişmez, navigate edilmez. `tabId` her zaman\r\n\t * yeni üretilir (ya da caller verdiyse o kullanılır), exists check YOKTUR; aynı path\r\n\t * birden fazla tab'da bağımsız yaşayabilir.\r\n\t */\r\n\topenInBackgroundTab(navItem: NavItem): void {\r\n\t\tif (this.activeRoutes().length >= this.MAX_TABS) {\r\n\t\t\tthis.notifyMaxTabsReached();\r\n\t\t\treturn;\r\n\t\t}\r\n\t\tconst tabId = navItem.tabId || this.generateTabId();\r\n\t\tconst navLink = cleanNavLink(navItem.navLink);\r\n\t\tthis.activeRoutes.update((val) => [...val, { ...navItem, tabId, navLink }]);\r\n\t}\r\n\r\n\t/**\r\n\t * Yeni tab aç ve o tab'a geç. Exists check YOK — aynı path'in iki ayrı tab'i kabul edilir;\r\n\t * her tab kendi `tabId`'siyle ayrı componentRef instantiate eder.\r\n\t */\r\n\topenInNewTabAndFocus(navItem: NavItem): void {\r\n\t\tif (this.activeRoutes().length >= this.MAX_TABS) {\r\n\t\t\tthis.notifyMaxTabsReached();\r\n\t\t\treturn;\r\n\t\t}\r\n\t\tconst tabId = navItem.tabId || this.generateTabId();\r\n\t\tconst navLink = cleanNavLink(navItem.navLink);\r\n\t\tthis.activeRoutes.update((val) => [...val, { ...navItem, tabId, navLink }]);\r\n\t\tsafeNavigate(this.router, withTabId(navLink, tabId), tabState(tabId));\r\n\t}\r\n\r\n\t/** Programatik tab ekleme; activeRoute observable refresh path'i bunu kullanır. */\r\n\taddToActiveRoutes(navItem: NavItem): void {\r\n\t\tif (this.activeRoutes().length >= this.MAX_TABS) {\r\n\t\t\t// Programmatic çağrı — toast göstermek yerine sessizce return.\r\n\t\t\treturn;\r\n\t\t}\r\n\t\tconst tabId = navItem.tabId || this.generateTabId();\r\n\t\tconst navLink = cleanNavLink(navItem.navLink);\r\n\t\t// Signal change detection reference identity ile çalışır — yeni array dön.\r\n\t\tthis.activeRoutes.update((val) => [...val, { ...navItem, tabId, navLink }]);\r\n\t}\r\n\r\n\t/**\r\n\t * Aktif tab'ı `activeTabId` üzerinden bulur. Aynı `navLink`'in birden fazla tab'i\r\n\t * olabileceği için navLink karşılaştırması ambiguous; tabId tek doğru kimlik.\r\n\t */\r\n\tprivate findActiveTabIndex(): number {\r\n\t\tconst tabId = this.activeTabId();\r\n\t\tif (!tabId) return -1;\r\n\t\treturn this.activeRoutes().findIndex((r) => r.tabId === tabId);\r\n\t}\r\n\r\n\t/** Tab limiti aşıldığında kullanıcıyı toast ile bilgilendirir. */\r\n\tprivate notifyMaxTabsReached(): void {\r\n\t\tthis.messageService.add({\r\n\t\t\tseverity: 'warn',\r\n\t\t\tsummary: this.translocoService.translate('tab.maxReachedSummary', { max: this.MAX_TABS }),\r\n\t\t\tdetail: this.translocoService.translate('tab.maxReachedDetail'),\r\n\t\t\tkey: 'toast-root'\r\n\t\t});\r\n\t}\r\n\r\n\t/** Anasayfa navLink'i — host menü root item'ından (yoksa '/'), clean format. */\r\n\tprivate homeNavLink(): string {\r\n\t\treturn cleanNavLink(this.homeNavItemProvider?.().navLink || '/');\r\n\t}\r\n\r\n\t/** Verilen tab anasayfaya mı ait. */\r\n\tprivate isHomeTab(item: NavItem): boolean {\r\n\t\treturn item.navLink === this.homeNavLink();\r\n\t}\r\n\r\n\t/**\r\n\t * Anasayfa tab'ı açıp ona navigate eder — tab listesi HİÇ boş kalmamalı (en az 1 tab).\r\n\t * NavItem host menü root item'ından gelir; yoksa `/` + i18n fallback ('tab.home', 'pi pi-home').\r\n\t */\r\n\tprivate openHomeTab(): Promise<boolean> {\r\n\t\tconst base = this.homeNavItemProvider?.();\r\n\t\tconst navLink = cleanNavLink(base?.navLink || '/');\r\n\t\tconst tabId = this.generateTabId();\r\n\t\tconst home: NavItem = {\r\n\t\t\ttabId,\r\n\t\t\tnavLink,\r\n\t\t\tnavName: base?.navName || this.translocoService.translate('tab.home'),\r\n\t\t\ticon: base?.icon || 'pi pi-home'\r\n\t\t};\r\n\t\tthis.activeRoutes.update((val) => [...val, home]);\r\n\t\treturn safeNavigate(this.router, withTabId(navLink, tabId), tabState(tabId));\r\n\t}\r\n\r\n\tcloseNavigation(navItem: NavItem): void {\r\n\t\t// `tabId` ile bul — aynı path'in birden fazla tab'i olabileceği için `navLink`\r\n\t\t// karşılaştırması ambiguous olur, kimlik bazlı arama tek doğru yöntem.\r\n\t\tconst idx = this.activeRoutes().findIndex((r) => r.tabId === navItem.tabId);\r\n\t\tconsole.log(`[NavService] closeNavigation tabId=\"${navItem.tabId}\" navLink=\"${navItem.navLink}\" index=${idx}`);\r\n\t\tif (idx === -1) return;\r\n\r\n\t\tconst closedItem = this.activeRoutes()[idx];\r\n\t\t// Son kalan tab anasayfaysa kapatma — her zaman en az 1 (anasayfa) tab açık kalmalı.\r\n\t\tif (this.activeRoutes().length === 1 && this.isHomeTab(closedItem)) return;\r\n\t\t// Signal change detection reference identity ile çalışır — yeni array dön.\r\n\t\tthis.activeRoutes.update((val) => val.filter((_, i) => i !== idx));\r\n\r\n\t\tconst cleanup = (): void => this.cleanupTabHandle(closedItem);\r\n\t\tconst closingActiveTab = this.activeTabId() === closedItem.tabId;\r\n\r\n\t\tif (closingActiveTab) {\r\n\t\t\t// Aktif tab kapatılıyor — başka tab'a (veya home'a) navigate edip cleanup'ı SONRA tetikle.\r\n\t\t\t// Aksi takdirde strategy henüz `store('mfe:${remoteName}:${tabId}', handle)`'i yapmadan\r\n\t\t\t// `deleteStoredRoute` çağrılır ve cleanup boş hit eder; ardından detach tamamlanınca\r\n\t\t\t// element hidden container'da orphan kalır (race condition).\r\n\t\t\tconst remaining = this.activeRoutes();\r\n\t\t\tconst willNavigateItem = remaining.length > 0 ? remaining[idx] || remaining[idx - 1] : null;\r\n\t\t\tif (willNavigateItem) {\r\n\t\t\t\tsafeNavigate(\r\n\t\t\t\t\tthis.router,\r\n\t\t\t\t\twithTabId(willNavigateItem.navLink, willNavigateItem.tabId),\r\n\t\t\t\t\ttabState(willNavigateItem.tabId)\r\n\t\t\t\t).finally(cleanup);\r\n\t\t\t} else {\r\n\t\t\t\t// Hiç tab kalmadı — boş bırakma, anasayfa tab'ı aç (en az 1 tab kuralı).\r\n\t\t\t\tthis.openHomeTab().finally(cleanup);\r\n\t\t\t}\r\n\t\t} else {\r\n\t\t\t// Aktif değildi — navigation gerekmez. Ancak arka planda açılıp (`openInBackgroundTab`)\r\n\t\t\t// hiç görüntülenmemiş tab henüz Router tarafından `store()` edilmemiş olabilir; cleanup'ı\r\n\t\t\t// bir microtask geciktirip olası store cycle'ına fırsat veriyoruz (orphan handle önlemi).\r\n\t\t\tvoid Promise.resolve().then(cleanup);\r\n\t\t}\r\n\t}\r\n\r\n\t/**\r\n\t * Bir tab hariç diğer tüm tab'ları kapatır. Aktif tab kapatılanlardan ise `keepItem`'a geçer.\r\n\t * **Sabit tab'lar korunur** (Chrome davranışı) — pinned olanlar her zaman açık kalır.\r\n\t */\r\n\tcloseOthers(keepItem: NavItem): void {\r\n\t\tconst all = this.activeRoutes();\r\n\t\tconst toClose = all.filter((r) => r.tabId !== keepItem.tabId && !r.pinned);\r\n\t\tif (toClose.length === 0) return;\r\n\t\tconst survivorIds = new Set([keepItem.tabId, ...all.filter((r) => r.pinned).map((r) => r.tabId)]);\r\n\t\tthis.activeRoutes.set(all.filter((r) => survivorIds.has(r.tabId)));\r\n\t\tconst cleanupAll = (): void => toClose.forEach((t) => this.cleanupTabHandle(t));\r\n\t\tif (this.activeTabId() !== keepItem.tabId) {\r\n\t\t\tsafeNavigate(\r\n\t\t\t\tthis.router,\r\n\t\t\t\twithTabId(keepItem.navLink, keepItem.tabId),\r\n\t\t\t\ttabState(keepItem.tabId)\r\n\t\t\t).finally(cleanupAll);\r\n\t\t} else {\r\n\t\t\tcleanupAll();\r\n\t\t}\r\n\t}\r\n\r\n\t/**\r\n\t * Verilen tab'ın sağındaki tüm tab'ları kapatır. **Sabit tab'lar korunur** —\r\n\t * pinned bir tab sağda olsa bile kapatılmaz (Chrome davranışı).\r\n\t */\r\n\tcloseToRight(item: NavItem): void {\r\n\t\tconst all = this.activeRoutes();\r\n\t\tconst idx = all.findIndex((r) => r.tabId === item.tabId);\r\n\t\tif (idx === -1) return;\r\n\t\tconst toClose = all.slice(idx + 1).filter((r) => !r.pinned);\r\n\t\tif (toClose.length === 0) return;\r\n\t\tconst toCloseIds = new Set(toClose.map((r) => r.tabId));\r\n\t\tthis.activeRoutes.set(all.filter((r) => !toCloseIds.has(r.tabId)));\r\n\t\tconst activeWasClosed = toClose.some((r) => r.tabId === this.activeTabId());\r\n\t\tconst cleanupAll = (): void => toClose.forEach((t) => this.cleanupTabHandle(t));\r\n\t\tif (activeWasClosed) {\r\n\t\t\tsafeNavigate(\r\n\t\t\t\tthis.router,\r\n\t\t\t\twithTabId(item.navLink, item.tabId),\r\n\t\t\t\ttabState(item.tabId)\r\n\t\t\t).finally(cleanupAll);\r\n\t\t} else {\r\n\t\t\tcleanupAll();\r\n\t\t}\r\n\t}\r\n\r\n\t/**\r\n\t * Sabit olmayan tüm tab'ları kapatır. **Sabit tab'lar korunur** — kullanıcı \"Tümünü Kapat\"\r\n\t * isterse bile pinned tab'lar açık kalır (Chrome davranışı). Hiç pinned tab yoksa ana sayfaya\r\n\t * navigate edilir.\r\n\t */\r\n\tcloseAll(): void {\r\n\t\tconst all = this.activeRoutes();\r\n\t\tif (all.length === 0) return;\r\n\t\tconst toClose = all.filter((r) => !r.pinned);\r\n\t\tif (toClose.length === 0) return;\r\n\t\tconst survivors = all.filter((r) => r.pinned);\r\n\t\tthis.activeRoutes.set(survivors);\r\n\t\tconst cleanupAll = (): void => toClose.forEach((t) => this.cleanupTabHandle(t));\r\n\t\t// Aktif tab kapatılanlardan ise: ya bir pinned tab'a geç (yaşıyorsa), yoksa ana sayfaya.\r\n\t\tconst activeWasClosed = toClose.some((r) => r.tabId === this.activeTabId());\r\n\t\tif (activeWasClosed) {\r\n\t\t\tif (survivors.length > 0) {\r\n\t\t\t\tconst target = survivors[0];\r\n\t\t\t\tsafeNavigate(this.router, withTabId(target.navLink, target.tabId), tabState(target.tabId)).finally(cleanupAll);\r\n\t\t\t} else {\r\n\t\t\t\t// Pinned survivor yok — boş bırakma, anasayfa tab'ı aç (en az 1 tab kuralı).\r\n\t\t\t\tthis.openHomeTab().finally(cleanupAll);\r\n\t\t\t}\r\n\t\t} else {\r\n\t\t\tcleanupAll();\r\n\t\t}\r\n\t}\r\n\r\n\t/**\r\n\t * Tab sabitleme toggle — Chrome-vari pinning. Pinned tab'lar tab bar'ın **soluna** taşınır\r\n\t * (insertion sırasını koruyarak), kompakt görünür, `closeOthers`/`closeToRight`/`closeAll`\r\n\t * çağrılarından korunur. Aynı pinned tıklanırsa sabitlemeyi kaldırır → normal alanın **sonuna**\r\n\t * taşınır.\r\n\t */\r\n\ttogglePin(item: NavItem): void {\r\n\t\tconst all = this.activeRoutes();\r\n\t\tconst idx = all.findIndex((r) => r.tabId === item.tabId);\r\n\t\tif (idx === -1) return;\r\n\t\tconst target = all[idx];\r\n\t\tconst newPinned = !target.pinned;\r\n\t\t// Önce target'ı array'den çıkar, sonra pinned/normal bloğunun **sonuna** ekle.\r\n\t\t// Bu Chrome davranışı: pinlenince pinned bloğun sonuna (en sağa), unpinlenince normal\r\n\t\t// bloğun başına (pinned'in hemen sağına).\r\n\t\tconst without = all.filter((_, i) => i !== idx);\r\n\t\tconst pinnedSegment = without.filter((r) => r.pinned);\r\n\t\tconst normalSegment = without.filter((r) => !r.pinned);\r\n\t\tconst updated: NavItem = { ...target, pinned: newPinned };\r\n\t\t// Pin → pinned bloğun sonuna; unpin → normal bloğun başına. Her iki durumda da `updated`,\r\n\t\t// pinned ve normal segmentlerin SINIRINA yerleşir (pozisyon aynı) → tek ifade yeterli.\r\n\t\tconst next = [...pinnedSegment, updated, ...normalSegment];\r\n\t\tthis.activeRoutes.set(next);\r\n\t}\r\n\r\n\t/** Sıradaki tab'a (circular) geçer. */\r\n\tgoToNextTab(): void {\r\n\t\tconst all = this.activeRoutes();\r\n\t\tif (all.length === 0) return;\r\n\t\tconst idx = this.findActiveTabIndex();\r\n\t\tconst nextIdx = idx === -1 ? 0 : (idx + 1) % all.length;\r\n\t\tconst target = all[nextIdx];\r\n\t\tsafeNavigate(this.router, withTabId(target.navLink, target.tabId), tabState(target.tabId));\r\n\t}\r\n\r\n\t/** Önceki tab'a (circular) geçer. */\r\n\tgoToPrevTab(): void {\r\n\t\tconst all = this.activeRoutes();\r\n\t\tif (all.length === 0) return;\r\n\t\tconst idx = this.findActiveTabIndex();\r\n\t\tconst prevIdx = idx === -1 ? all.length - 1 : (idx - 1 + all.length) % all.length;\r\n\t\tconst target = all[prevIdx];\r\n\t\tsafeNavigate(this.router, withTabId(target.navLink, target.tabId), tabState(target.tabId));\r\n\t}\r\n\r\n\t/** Index'teki tab'a geçer (Alt+1..9 için 0-tabanlı index). */\r\n\tgoToTabByIndex(index: number): void {\r\n\t\tconst all = this.activeRoutes();\r\n\t\tif (index < 0 || index >= all.length) return;\r\n\t\tconst target = all[index];\r\n\t\tsafeNavigate(this.router, withTabId(target.navLink, target.tabId), tabState(target.tabId));\r\n\t}\r\n\r\n\t/**\r\n\t * Verilen tab'a navigate — UI'dan (tab tıklama) çağrılır. Router'a `_tab` ile URL ve\r\n\t * `extras.state` ile tabId verir; UrlSerializer adres çubuğunu temiz tutar.\r\n\t */\r\n\tnavigateToTab(item: NavItem): void {\r\n\t\tif (!item?.navLink || !item?.tabId) return;\r\n\t\tconst url = withTabId(item.navLink, item.tabId);\r\n\t\tconsole.log(`[NavService] navigateToTab tabId=\"${item.tabId}\" navLink=\"${item.navLink}\" → url=\"${url}\"`);\r\n\t\tsafeNavigate(this.router, url, tabState(item.tabId));\r\n\t}\r\n\r\n\t/**\r\n\t * Belirli bir tab'ın `navLink`'ini ve (varsa) `navName`'ini günceller. **Kaynağa-bağlı**\r\n\t * (per-tab) sync — caller hangi tab'ın URL'i olduğunu söyler, NavService aktif tab\r\n\t * varsayımında bulunmaz. Hidden container'daki async MFE NavigationEnd'leri aktif tab'ın\r\n\t * state'ini KONTAMİNE EDEMEZ.\r\n\t *\r\n\t * `title` parametresi MFE Router deepest route'unun `Route.title` veya `data.tabName`\r\n\t * değerinden gelir → kullanıcı detail/edit gibi sub-sayfalara navigate olduğunda tab\r\n\t * adı dinamik güncellenir. `title` undefined ise tab.navName değişmez (statik kalır).\r\n\t *\r\n\t * AppLayoutComponent effect'ten `bridge.activeMFEUrl` (`{tabId, url, title}`) ile çağrılır.\r\n\t */\r\n\tsyncActiveTabNavLinkForTab(tabId: string, rawUrl: string, title?: string): void {\r\n\t\tif (!tabId || !rawUrl) return;\r\n\t\tconst cleanUrl = cleanNavLink(rawUrl);\r\n\t\tconst target = this.activeRoutes().find((t) => t.tabId === tabId);\r\n\t\tif (!target) return;\r\n\t\tconst linkChanged = target.navLink !== cleanUrl;\r\n\t\tconst nameChanged = !!title && target.navName !== title;\r\n\t\tif (!linkChanged && !nameChanged) return;\r\n\t\tconst newNavLink = linkChanged ? cleanUrl : target.navLink;\r\n\t\tconst newName = nameChanged ? title! : target.navName;\r\n\t\tconsole.log(\r\n\t\t\t`[NavService] syncActiveTabNavLinkForTab tab=\"${tabId}\" ` +\r\n\t\t\t`navLink \"${target.navLink}\" → \"${newNavLink}\" name \"${target.navName}\" → \"${newName}\"`\r\n\t\t);\r\n\t\tthis.activeRoutes.update((routes) =>\r\n\t\t\troutes.map((t) => (t.tabId === tabId ? { ...t, navLink: newNavLink, navName: newName } : t))\r\n\t\t);\r\n\t}\r\n\r\n\t/**\r\n\t * Tab context-menu \"Yinele\" (Chrome \"Duplicate\"): mevcut tab'ın path'i kopyalanır, yeni bir\r\n\t * `tabId` üretilir ve yeni tab oluşturulur. Strategy `_tab` query param'ını route key'in\r\n\t * parçası yaptığı için yeni tab bağımsız `storedRoutes` slot'una yazılır → bağımsız\r\n\t * componentRef + state. Mevcut tab korunur, kullanıcı her ikisinde de bağımsız çalışabilir.\r\n\t */\r\n\tduplicateTab(item: NavItem): void {\r\n\t\tif (!item?.navLink) return;\r\n\t\tif (this.activeRoutes().length >= this.MAX_TABS) {\r\n\t\t\tthis.notifyMaxTabsReached();\r\n\t\t\treturn;\r\n\t\t}\r\n\t\tconst newTabId = this.generateTabId();\r\n\t\tconst newNavLink = cleanNavLink(item.navLink);\r\n\t\tthis.activeRoutes.update((val) => [\r\n\t\t\t...val,\r\n\t\t\t{ ...item, tabId: newTabId, navLink: newNavLink }\r\n\t\t]);\r\n\t\tsafeNavigate(this.router, withTabId(newNavLink, newTabId), tabState(newTabId));\r\n\t}\r\n\r\n\treorderActiveRoutes(newRoutes: NavItem[]): void {\r\n\t\t// Pinned/normal sınırı koruması — sabit tab'lar tab bar'ın solunda (insertion sırasıyla),\r\n\t\t// normal tab'lar sağında kalır. CDK drag drop bir tab'ı yanlış segmente düşürürse\r\n\t\t// burada otomatik düzeltilir. Segment içi sıra korunur.\r\n\t\tconst pinned = newRoutes.filter((r) => r.pinned);\r\n\t\tconst normal = newRoutes.filter((r) => !r.pinned);\r\n\t\tthis.activeRoutes.set([...pinned, ...normal]);\r\n\t}\r\n\r\n\t/**\r\n\t * Menu config'inden navLink'e karşılık gelen item'i longest-prefix match ile bulup\r\n\t * aktif dilde label + icon döner. Adres çubuğuna URL yapıştırarak deep link açıldığında\r\n\t * tab'ın menüden açılan tab'la aynı görünüme sahip olmasını sağlar.\r\n\t *\r\n\t * Lookup `menuItemsProvider` üzerinden — host shell `setMenuItemsProvider` ile\r\n\t * `bridge.hostMenuItems()`'a bağlar. Provider yoksa veya eşleşme yoksa `null` döner ve\r\n\t * caller URL segment fallback'ine düşer.\r\n\t */\r\n\tprivate resolveNavInfoFromMenu(navLink: string): { navName: string; icon?: string } | null {\r\n\t\t// Anasayfa (menüdeki `root` öğesi) çoğu zaman `routerLink` ile eşleşmez (routerLink'i `/`\r\n\t\t// veya boş olabilir, longest-prefix match'e takılmaz) → `/` için fallback \"Page\" + jenerik\r\n\t\t// ikon dönerdi. Home provider varsa ad/ikonu doğrudan oradan (root item'dan) çöz.\r\n\t\tif (this.homeNavItemProvider) {\r\n\t\t\tconst home = this.homeNavItemProvider();\r\n\t\t\t// Anasayfa navLink eşleşiyorsa dön — menü boş/geç yüklendiyse ya da menüde `root` öğesi\r\n\t\t\t// yoksa navName/icon boş gelebilir; i18n ('tab.home') + ev ikonu fallback ile asla\r\n\t\t\t// menü-segment fallback'ine (\"Page\") düşme.\r\n\t\t\tif (navLink === cleanNavLink(home.navLink || '/')) {\r\n\t\t\t\treturn {\r\n\t\t\t\t\tnavName: home.navName || this.translocoService.translate('tab.home'),\r\n\t\t\t\t\ticon: home.icon || 'pi pi-home'\r\n\t\t\t\t};\r\n\t\t\t}\r\n\t\t}\r\n\t\tconst items = this.menuItemsProvider?.();\r\n\t\tif (!items?.length) return null;\r\n\t\tconst path = navLink.split('?')[0];\r\n\t\tconst matched = this.findMenuItemForRoute(items, path);\r\n\t\tif (!matched) return null;\r\n\t\tconst lang = this.translocoService.getActiveLang();\r\n\t\tconst label = matched.label as Record<string, string> | undefined;\r\n\t\tconst navName = label?.[lang] || label?.['tr'] || label?.['en'] || '';\r\n\t\tif (!navName) return null;\r\n\t\treturn { navName, icon: matched.icon };\r\n\t}\r\n\r\n\t/**\r\n\t * Menü/i18n yüklenince tab'ları (özellikle anasayfa) menüyle revize eder — refresh/ilk açılış\r\n\t * path'inde tab fallback isim/iconla eklenmiş olabilir (menü veya çeviri o anda hazır değildi).\r\n\t * Tetikleyiciler: `setMenuItemsProvider`/`setHomeNavItemProvider`, `translationLoadSuccess`\r\n\t * event'i ve host shell menü signal'i değişimi (`AppLayoutComponent` effect). Public — host\r\n\t * layout menü async yüklenince çağırır ki anasayfa adı `tab.home` fallback'inde takılmasın.\r\n\t */\r\n\treconcileTabsWithMenu(): void {\r\n\t\tconst tabs = this.activeRoutes();\r\n\t\tif (!tabs.length) return;\r\n\t\tlet changed = false;\r\n\t\tconst next = tabs.map((t) => {\r\n\t\t\tconst info = this.resolveNavInfoFromMenu(t.navLink);\r\n\t\t\tif (!info) return t;\r\n\t\t\tif (t.navName === info.navName && t.icon === info.icon) return t;\r\n\t\t\tchanged = true;\r\n\t\t\treturn { ...t, navName: info.navName, icon: info.icon };\r\n\t\t});\r\n\t\tif (changed) this.activeRoutes.set(next);\r\n\t}\r\n\r\n\t/**\r\n\t * Menu ağacında verilen path için en spesifik (longest routerLink prefix) eşleşmeyi bulur.\r\n\t * `mw/app-management/view-app` için hem `mw` hem `mw/app-management/view-app` eşleşse,\r\n\t * daha uzun olan kazanır → leaf menu item'ın label/icon'u kullanılır.\r\n\t *\r\n\t * Path leading slash içerebilir (Router URL formatı), menu config routerLink'leri\r\n\t * genelde leading slash'sız (`mw/meters`); ikisini normalize edip karşılaştırırız.\r\n\t */\r\n\tprivate findMenuItemForRoute(items: PluginMenuItem[], path: string): PluginMenuItem | undefined {\r\n\t\tconst normalize = (p: string): string => (p.startsWith('/') ? p.slice(1) : p);\r\n\t\tconst normalizedPath = normalize(path);\r\n\t\tlet best: { length: number; item: PluginMenuItem } | undefined;\r\n\t\tconst visit = (list: PluginMenuItem[]): void => {\r\n\t\t\tfor (const it of list) {\r\n\t\t\t\tif (it.routerLink) {\r\n\t\t\t\t\tconst r = normalize(it.routerLink);\r\n\t\t\t\t\tif (r && (normalizedPath === r || normalizedPath.startsWith(r + '/'))) {\r\n\t\t\t\t\t\tconst length = r.length;\r\n\t\t\t\t\t\tif (!best || length > best.length) best = { length, item: it };\r\n\t\t\t\t\t}\r\n\t\t\t\t}\r\n\t\t\t\tif (it.items?.length) visit(it.items);\r\n\t\t\t}\r\n\t\t};\r\n\t\tvisit(items);\r\n\t\treturn best?.item;\r\n\t}\r\n\r\n\t/**\r\n\t * Bir tab'ın stored route handle'ını strategy'den temizler. Key formatı\r\n\t * `mfe:${remoteName}:${tabId}` — strategy `processCleanupKey` matcher key'inden hem\r\n\t * MFE custom element handle'ını hem o tab'a ait child route handle'larını düşürür.\r\n\t */\r\n\tprivate cleanupTabHandle(item: NavItem): void {\r\n\t\tconst remoteName = extractRemoteName(item.navLink);\r\n\t\tif (!remoteName || !item.tabId) return;\r\n\t\tconsole.log(`[NavService] cleanupTabHandle remoteName=\"${remoteName}\" tabId=\"${item.tabId}\"`);\r\n\t\tthis.routeCloseService.deleteStoredRoute(`mfe:${remoteName}:${item.tabId}`);\r\n\t}\r\n}\r\n"]}