aril 1.2.17 → 2.0.1-dev.0

package/fesm2022/aril.mjs

@@ -1,20 +1,23 @@
+import { Location, LocationStrategy } from '@angular/common';
 import { HttpClient } from '@angular/common/http';
 import * as i0 from '@angular/core';
-import { inject, NgZone, Component, APP_INITIALIZER, importProvidersFrom } from '@angular/core';
+import { inject, NgZone, Component, APP_INITIALIZER, Injectable, importProvidersFrom, ɵINJECTOR_SCOPE as _INJECTOR_SCOPE, ApplicationRef, createEnvironmentInjector, isDevMode, createComponent } from '@angular/core';
 import { bootstrapApplication, createApplication } from '@angular/platform-browser';
-import { provideRouter, withComponentInputBinding, withHashLocation, withViewTransitions, withRouterConfig, RouteReuseStrategy, Router } from '@angular/router';
+import { provideRouter, withComponentInputBinding, withHashLocation, withRouterConfig, RouteReuseStrategy, UrlSerializer, Router } from '@angular/router';
 import { KeycloakService } from 'keycloak-angular';
 import { createBaseAppConfig, HOST_I18N_FOLDER } from 'aril/boot/base';
 import * as i3 from 'aril/boot/bridge';
 import { bridge } from 'aril/boot/bridge';
 import { loadApiConfigs, loadInitData, setApiConfigOnMFEMode } from 'aril/boot/config/api';
-import { ArilReuseStrategy, MicroAppService } from 'aril/boot/config/apps';
+import { CustomRouteReuseStrategy, TabAwareUrlSerializer, MicroAppService } from 'aril/boot/config/apps';
 import { loadPlugins, getNgZone } from 'aril/boot/config/plugins';
 import { i18nFolderName } from 'aril/i18n';
 import * as i1 from 'aril/theme/layout';
 import { AppLayoutComponent } from 'aril/theme/layout';
 import * as i2 from 'aril/util/pub-sub';
-import { createCustomElement } from '@angular/elements';
+import { PubSubService } from 'aril/util/pub-sub';
+import { PrimeNGConfig, MessageService, ConfirmationService } from 'primeng/api';
+import { TranslocoService } from '@ngneat/transloco';
 import { MonacoEditorModule, NGX_MONACO_EDITOR_CONFIG } from 'ngx-monaco-editor-v2';
 import { provideHost } from 'aril/provider';
 
@@ -25,7 +28,6 @@ class AppComponent {
         this.bridgeSvc = bridgeSvc;
         this.bridgeSvc.mirrorToWindow();
         this.bridgeSvc.activeHost.set(appName$1);
-        this.bridgeSvc.isHostMode.set(true);
         this.bridgeSvc.hostNgZone = inject(NgZone);
         this.pubSubService.subscribe('menuModeChanged', (data) => {
             const menuMode = data?.custom;
@@ -67,13 +69,27 @@ const boot$1 = (_appName, routes) => {
     const appConfig = {
         providers: [
             createBaseAppConfig({ i18nFolder: HOST_I18N_FOLDER }),
-            provideRouter(routes, withComponentInputBinding(), withHashLocation(), withViewTransitions(), withRouterConfig({ onSameUrlNavigation: 'reload' })),
-            { provide: RouteReuseStrategy, useClass: ArilReuseStrategy },
+            provideRouter(routes, withComponentInputBinding(), withHashLocation(), withRouterConfig({ onSameUrlNavigation: 'reload' })),
+            // `useExisting`: `CustomRouteReuseStrategy` `providedIn: 'root'` olduğu için root injector'da
+            // zaten bir instance var. Router'a aynı instance'ı bağlamak ileride class'a doğrudan
+            // erişmek isteyen tüketiciler (örn. test hook'ları, debug paneli) için tek-instance
+            // garantisi sağlar.
+            {
+                provide: RouteReuseStrategy,
+                useExisting: CustomRouteReuseStrategy
+            },
+            // `_tab` query param'ı address bar'dan strip eder; Router internal `queryParams`'ı korur.
+            {
+                provide: UrlSerializer,
+                useExisting: TabAwareUrlSerializer
+            },
             {
                 provide: APP_INITIALIZER,
-                useFactory: (httpClient, keycloak, router, folderName, microAppService) => {
+                useFactory: (httpClient, keycloak, router, folderName, microAppService, location) => {
                     if (router)
                         bridge.hostRouter = router;
+                    if (location)
+                        bridge.hostLocation = location;
                     const runLoadApiConfigs = loadApiConfigs(httpClient, keycloak, folderName, microAppService);
                     const runLoadInitData = loadInitData(httpClient);
                     const runLoadPlugins = loadPlugins();
@@ -84,7 +100,7 @@ const boot$1 = (_appName, routes) => {
                     };
                 },
                 multi: true,
-                deps: [HttpClient, KeycloakService, Router, i18nFolderName, MicroAppService]
+                deps: [HttpClient, KeycloakService, Router, i18nFolderName, MicroAppService, Location]
             }
         ]
     };
@@ -92,10 +108,149 @@ const boot$1 = (_appName, routes) => {
 };
 
 const appComponentLoader = async () => {
-    const { AppComponent } = await import('./aril-app.component-wxP3y8dg.mjs');
+    const { AppComponent } = await import('./aril-app.component-s14ruALV.mjs');
     return AppComponent;
 };
 
+/**
+ * Host modda her MFE Application'ı için kullanılan custom `LocationStrategy`. Browser
+ * URL'ine (`window.location.hash`) HİÇ YAZMAZ; tüm path/state internal alanlarda tutulur.
+ *
+ * Neden? Host modda host Router yegane URL kontrolcüsüdür. Eğer MFE Router da
+ * `HashLocationStrategy` kullansaydı, MFE içindeki bir `routerLink` tıklaması browser hash'ını
+ * değiştirir → `HashLocationStrategy` host Router'ı OTOMATİK tetikler → host Router'a
+ * tabsız (state'siz) navigation gelir → Strategy yanlış componentRef yaratır, tab
+ * izolasyonu bozulur. Bu otomatik sync'i kırmak için MFE Router'ın LocationStrategy'sini
+ * isolate ediyoruz: MFE içi navigation MFE Router'ın internal state'inde kalır, browser'a
+ * sızmaz, host'a istemsiz event göndermez.
+ *
+ * ## Tab içi history stack
+ * Browser back/forward butonu yerine MFE içinde **tab-içi history stack** çalışır:
+ * `pushState` her yeni navigation'da `backStack`'e mevcut konumu iter, `forwardStack`'i
+ * temizler; `back()` ve `forward()` stack'ler arasında değiş tokuş yapıp `popstate` event'i
+ * emit eder — Angular `Location` service bunu Router'a iletir, Router popstate-driven
+ * navigation cycle başlatır. Sonuçta kullanıcı **detay → liste** gibi MFE içi geri dönüşleri
+ * browser back butonuyla yapabilir, ama bu navigation **host Router'a yansımaz** → tab
+ * izolasyonu korunur, "geri" başka tab'a atlatmaz.
+ */
+class IsolatedLocationStrategy extends LocationStrategy {
+    /**
+     * Stack boyutu üst limiti — browser default'una (50 entry) yakın. Aşırı uzun
+     * session'larda memory'i sınırlı tutar; sınır aşıldığında en eski entry düşürülür.
+     */
+    static { this.MAX_STACK_SIZE = 50; }
+    constructor() {
+        super();
+        this.internalPath = '/';
+        this.internalState = null;
+        /** Geri gidilebilecek path/state çiftleri (LIFO). */
+        this.backStack = [];
+        /** İleri gidilebilecek path/state çiftleri (`back()` ile pop edilen entry'ler). */
+        this.forwardStack = [];
+        this.popStateHandlers = [];
+        /**
+         * `back/forward` sonrası Router'ın navigation cycle'ı sırasında çağrılabilen
+         * `pushState`'i `backStack`'e tekrar itmemek için flag. `replaceState` zaten stack'i
+         * değiştirmiyor — bu flag yalnızca pushState yolunu koruyor.
+         */
+        this.isNavigatingViaHistory = false;
+        console.log('[IsolatedLocationStrategy] CONSTRUCTED — host modda MFE Router için aktif');
+    }
+    path(_includeHash) {
+        return this.internalPath;
+    }
+    prepareExternalUrl(internal) {
+        // Host `HashLocationStrategy` (withHashLocation) kullanıyor → MFE routerLink'lerinin
+        // ürettiği `<a href>` (hover/kopyalama/orta-tık/yeni sekme) host ile uyumlu `#/...`
+        // formatında olmalı. Sol-tık navigation'ı zaten host Router proxy üzerinden gider
+        // (href kullanılmaz); bu override yalnız görünen/kopyalanan URL'i düzeltir.
+        return internal.length > 0 ? '#' + internal : internal;
+    }
+    pushState(state, _title, url, queryParams) {
+        const fullPath = url + (queryParams ? `?${queryParams}` : '');
+        console.log(`[IsolatedLocationStrategy] pushState url="${url}" qs="${queryParams}" viaHistory=${this.isNavigatingViaHistory}`);
+        if (!this.isNavigatingViaHistory) {
+            // Yeni navigation → mevcut konumu backStack'e it, forwardStack'i temizle
+            // (browser semantiği: yeni sayfaya gidince forward history düşer).
+            if (this.internalPath !== fullPath) {
+                this.backStack.push({ path: this.internalPath, state: this.internalState });
+                if (this.backStack.length > IsolatedLocationStrategy.MAX_STACK_SIZE) {
+                    this.backStack.shift();
+                }
+                this.forwardStack = [];
+            }
+        }
+        this.internalPath = fullPath;
+        this.internalState = state;
+    }
+    replaceState(state, _title, url, queryParams) {
+        console.log(`[IsolatedLocationStrategy] replaceState url="${url}" qs="${queryParams}"`);
+        this.internalPath = url + (queryParams ? `?${queryParams}` : '');
+        this.internalState = state;
+    }
+    back() {
+        const prev = this.backStack.pop();
+        if (!prev)
+            return;
+        this.forwardStack.push({ path: this.internalPath, state: this.internalState });
+        this.internalPath = prev.path;
+        this.internalState = prev.state;
+        this.emitPopState();
+    }
+    forward() {
+        const next = this.forwardStack.pop();
+        if (!next)
+            return;
+        this.backStack.push({ path: this.internalPath, state: this.internalState });
+        this.internalPath = next.path;
+        this.internalState = next.state;
+        this.emitPopState();
+    }
+    historyGo(relativePosition) {
+        if (relativePosition < 0) {
+            const steps = -relativePosition;
+            for (let i = 0; i < steps && this.backStack.length; i++)
+                this.back();
+        }
+        else if (relativePosition > 0) {
+            for (let i = 0; i < relativePosition && this.forwardStack.length; i++)
+                this.forward();
+        }
+    }
+    onPopState(fn) {
+        this.popStateHandlers.push(fn);
+    }
+    emitPopState() {
+        this.isNavigatingViaHistory = true;
+        try {
+            const event = new PopStateEvent('popstate', { state: this.internalState });
+            for (const fn of this.popStateHandlers)
+                fn(event);
+        }
+        finally {
+            // Router'ın navigation cycle'ı async — popstate handler'ı navigation tetikledikten
+            // sonra cycle bittiğinde pushState/replaceState çağrılabilir. Microtask sınırı
+            // sync cycle'ı kapsar; daha güvenli istersek `queueMicrotask` yerine `setTimeout(0)`
+            // tercih edilebilir ama bu durumda araya gerçek user navigation girebilir. Microtask
+            // pratikte yeterli: Router popstate cycle'ında pushState değil replaceState çağırır.
+            queueMicrotask(() => {
+                this.isNavigatingViaHistory = false;
+            });
+        }
+    }
+    getBaseHref() {
+        return '/';
+    }
+    getState() {
+        return this.internalState;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.1.2", ngImport: i0, type: IsolatedLocationStrategy, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.1.2", ngImport: i0, type: IsolatedLocationStrategy }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.1.2", ngImport: i0, type: IsolatedLocationStrategy, decorators: [{
+            type: Injectable
+        }], ctorParameters: () => [] });
+
 const monacoConfig = {
     baseUrl: 'assets',
     defaultOptions: { scrollBeyondLastLine: false },
@@ -345,24 +500,35 @@ const monacoConfig = {
 
 var appName;
 var menuItems = [];
+/**
+ * `boot` çağrılarının idempotent kalmasını sağlayan sync guard. Aynı remote için
+ * birden fazla paralel `boot('wdm', ...)` çağrısı geldiğinde, ilk `customElements.define`
+ * tamamlanmadan ikinci çağrı `customElements.get` guard'ını geçiyordu → her ikisi de
+ * define etmeye çalışıp `NotSupportedError: the name "app-wdm" has already been used`
+ * hatası fırlatılıyordu. Set ile sync mark ederek tek bir define cycle'ı garanti ediyoruz.
+ */
+const bootedApps = new Set();
 const boot = (_appName, _routes, _menuItems) => {
-    if (customElements.get(`app-${_appName}`))
+    if (bootedApps.has(_appName) || customElements.get(`app-${_appName}`))
         return;
+    bootedApps.add(_appName);
     appName = _appName;
     menuItems = _menuItems;
-    const appBootConfig = {
+    /**
+     * **Paylaşılan base config** — remote başına TEK `createApplication`. Ağır servisler
+     * (HttpClient + interceptor chain, Keycloak, i18n/Transloco, Monaco, animations) burada
+     * yaşar; `providedIn` taşımayan explicit provider oldukları için tüm tab'ların child
+     * injector'larından parent olarak paylaşılır → RAM lineer büyümez. Router/Location/
+     * ReuseStrategy/UrlSerializer burada YOK; onlar tab başına izole child injector'da verilir.
+     */
+    const sharedBaseConfig = {
         providers: [
             createBaseAppConfig({ i18nFolder: _appName }),
-            provideHost(appName),
-            provideRouter(_routes, withComponentInputBinding(), withHashLocation(), withViewTransitions(), withRouterConfig({ onSameUrlNavigation: 'reload' })),
-            { provide: RouteReuseStrategy, useClass: ArilReuseStrategy },
+            provideHost(_appName),
             getNgZone(),
             {
                 provide: APP_INITIALIZER,
                 useFactory: (httpClient, keycloak, folderName) => {
-                    if (!bridge.isHostMode()) {
-                        return () => Promise.resolve();
-                    }
                     const runApiInit = setApiConfigOnMFEMode(httpClient, keycloak, folderName);
                     const runLoadPlugins = loadPlugins();
                     return async () => {
@@ -377,17 +543,180 @@ const boot = (_appName, _routes, _menuItems) => {
             { provide: NGX_MONACO_EDITOR_CONFIG, useValue: monacoConfig }
         ]
     };
-    createApplication(appBootConfig).then((appRef) => {
-        appComponentLoader().then((AppComponent) => {
-            const app = createCustomElement(AppComponent, { injector: appRef.injector });
-            customElements.define(`app-${appName}`, app);
-        });
-    });
+    /**
+     * Remote başına TEK paylaşılan `ApplicationRef` — closure-scope. İlk `<app-${appName}>`
+     * element'i `createApplication(sharedBaseConfig)` çağırır, sonraki tüm element'ler aynı
+     * promise'ı bekler (duplicate Application yaratımı imkânsız). Her element kendi child
+     * injector + `createComponent` ile kendi `AppComponent` view'ını yaratıp shared app'e
+     * `attachView` ile bağlar. Shared app uzun ömürlüdür (tab'lar kapansa da destroy edilmez).
+     *
+     * `childProviders`'taki `TranslocoService` factory'si bu referansı kullandığı için
+     * `childProviders`'tan ÖNCE tanımlanır (forward TDZ'yi önler).
+     */
+    let sharedAppRef = null;
+    let sharedAppPromise = null;
+    /**
+     * **Tab başına izole Router stack** — her `<app-${appName}>` kendi child
+     * `EnvironmentInjector`'ında bunları alır. `ɵINJECTOR_SCOPE: 'root'` child'ı 'root'
+     * scope yapar (Angular `R3Injector` ctor: `scopes.add('root')`); böylece `provideRouter`'ın
+     * inject ettiği `providedIn:'root'` Router servisleri — `Router`, `ChildrenOutletContexts`,
+     * `Location`, `NavigationTransitions` vb. — child-LOCAL üretilir. Sonuç: her tab kendi
+     * Router + kendi `RouterOutlet` context'ine sahip olur → **1 Router : 1 outlet**.
+     *
+     * Neden gerekli: paylaşılan tek Application'da N `<router-outlet>` aynı tek
+     * `ChildrenOutletContexts`'e "primary" diye kaydolup birbirini eziyordu (`contexts.set`
+     * overwrite) → tab geçişi sonrası aynı tab içi navigasyon (list→detail) yanlış outlet'e
+     * render oluyordu. Child-injector izolasyonu bunu kökten çözer.
+     *
+     * **TranslocoService istisnası**: `'root'` scope onu da child-local yapardı; ama global
+     * (scope'suz) çeviriler shared app'in init akışında yüklendiğinden — `createComponent`
+     * `APP_INITIALIZER` çalıştırmaz — child-local service'in global cache'i boş kalıp ham key
+     * gösteriyordu. Tab başına ayrı dil senaryosu yok; service'i shared app'ten paylaştırıyoruz
+     * (global çeviri tek yerde yüklenir, tek translation cache → ek RAM kazancı). Scope çevirileri
+     * (`providei18nScope`) component-level sağlandığı için paylaşılan service'le de çalışır.
+     *
+     * NOT: `ɵINJECTOR_SCOPE` Angular private API'sidir; minor sürüm yükseltmelerinde davranışı
+     * doğrulanmalı (aşağıdaki POC izolasyon log'u bunun için bırakıldı).
+     */
+    const childProviders = [
+        { provide: _INJECTOR_SCOPE, useValue: 'root' },
+        provideRouter(_routes, withComponentInputBinding(), withRouterConfig({ onSameUrlNavigation: 'reload' })),
+        { provide: LocationStrategy, useClass: IsolatedLocationStrategy },
+        { provide: Location, useClass: Location },
+        { provide: RouteReuseStrategy, useExisting: CustomRouteReuseStrategy },
+        { provide: UrlSerializer, useExisting: TabAwareUrlSerializer },
+        { provide: TranslocoService, useFactory: () => sharedAppRef.injector.get(TranslocoService) },
+        // `ɵINJECTOR_SCOPE:'root'` yan etkisi: `ApplicationRef` de `providedIn:'root'` olduğu için
+        // child injector'da child-LOKAL (sahte) bir instance üretilirdi — bu instance NgZone'un
+        // tick döngüsüne bağlı DEĞİLDİR. Sonuç: bu appRef'e `attachView` edilen view'lar hiç change
+        // detection almaz. AppComponent'i biz açıkça `sharedAppRef.attachView` ile bağladığımız için
+        // çalışır; ama `inject(ApplicationRef)` yapan üçüncü taraf kod (PrimeNG `DialogService` →
+        // `this.appRef.attachView`) child-local sahte appRef'i alıp dialog'u ona bağlıyordu → dialog
+        // yaratılıyor ama `*ngIf="visible"` hiç render edilmiyordu (boş açılıyordu). Gerçek (tek,
+        // tick alan) `sharedAppRef`'e sabitliyoruz.
+        { provide: ApplicationRef, useFactory: () => sharedAppRef },
+        // Tarama (log15) ile saptanan, child-local olunca bozulan ek `providedIn:'root'` servisleri:
+        // • PubSubService — MFE'nin `breadcrumbUpdated` event'i host `history.service`'e ulaşmalı;
+        //   child-local olunca MFE↔host event köprüsü kopuyordu.
+        // • PrimeNGConfig — dinamik dialog'lar shared root context'inde yaratıldığı için PrimeNG
+        //   çevirileri (calendar/paginator vb.) ve `setTranslation` shared instance'tan okunmalı.
+        // (BreadcrumbService bilinçli olarak child-local bırakıldı: her tab kendi breadcrumb'ı.)
+        { provide: PubSubService, useFactory: () => sharedAppRef.injector.get(PubSubService) },
+        { provide: PrimeNGConfig, useFactory: () => sharedAppRef.injector.get(PrimeNGConfig) },
+        // Toast/confirm GLOBAL: tek shared MessageService/ConfirmationService. Aksi halde her tab
+        // kendi instance'ına sahip olur → host'tan tetiklenen toast MFE tab'ında (ya da tersi)
+        // görünmez. Shared instance ile tüm `<p-toast key="toast-root">` container'ları aynı kuyruğu dinler.
+        { provide: MessageService, useFactory: () => sharedAppRef.injector.get(MessageService) },
+        { provide: ConfirmationService, useFactory: () => sharedAppRef.injector.get(ConfirmationService) }
+    ];
+    const appComponentPromise = appComponentLoader();
+    class MFEAppElement extends HTMLElement {
+        constructor() {
+            super(...arguments);
+            this.childInjector = null;
+            this.compRef = null;
+            this.isBootstrapping = false;
+            this.destroyTimer = null;
+        }
+        async connectedCallback() {
+            // Strategy hidden container ↔ view arası taşımalarda re-bootstrap'ı önle —
+            // view zaten yaratıldıysa skip. destroyTimer pending ise iptal et.
+            if (this.compRef || this.isBootstrapping) {
+                if (this.destroyTimer) {
+                    clearTimeout(this.destroyTimer);
+                    this.destroyTimer = null;
+                }
+                return;
+            }
+            this.isBootstrapping = true;
+            try {
+                // Paylaşılan Application — ilk çağıran yaratır, diğerleri aynı promise'ı bekler.
+                if (!sharedAppPromise) {
+                    sharedAppPromise = createApplication(sharedBaseConfig);
+                }
+                const [appRef, AppComponent] = await Promise.all([sharedAppPromise, appComponentPromise]);
+                sharedAppRef = appRef;
+                // Bu tab için izole Router stack'i barındıran child injector.
+                const tabId = this.getAttribute('aril-tab-id') ?? '';
+                this.childInjector = createEnvironmentInjector(childProviders, appRef.injector, `mfe:${_appName}:${tabId || 'pending'}`);
+                // [Hibrit izolasyon guard — kalıcı] `ɵINJECTOR_SCOPE:'root'` ile child injector'ın
+                // KENDİ Router + ChildrenOutletContexts'i olması, tab izolasyonunun temelidir
+                // ("1 Router : 1 outlet"). Bu private API Angular upgrade'inde davranış değiştirirse
+                // burada erken yakalanır; aksi halde "1 Router : N outlet" bug'ı sessizce geri döner.
+                if (isDevMode() && this.childInjector.get(Router) === appRef.injector.get(Router)) {
+                    console.error(`[boot:${_appName}] HİBRİT İZOLASYON BOZULDU: child Router shared root ile aynı instance! ` +
+                        `ɵINJECTOR_SCOPE davranışı değişmiş olabilir (Angular upgrade?) — tab izolasyonu çalışmaz.`);
+                }
+                // AppComponent'i child injector context'inde yarat → inject(Router)/LocationStrategy
+                // child-local; inject(MfeBridge)/HttpClient/Keycloak/TranslocoService vb. parent'tan
+                // paylaşımlı. `attachView` shared app'in change detection döngüsüne bağlar. (`bootstrap`
+                // değil: APP_BOOTSTRAP_LISTENER çalışmaz, child Router'ın initial navigation'ını
+                // AppComponent host-Router sync'i `safeNavigate` ile yapıyor.)
+                this.compRef = createComponent(AppComponent, {
+                    environmentInjector: this.childInjector,
+                    hostElement: this
+                });
+                appRef.attachView(this.compRef.hostView);
+                // Başarılı boot: guard artık `compRef` üzerinden çalışır → `isBootstrapping`'i bırak.
+                // (await sırasında disconnect olup hata oluşmazsa flag takılı kalmasın; aksi halde
+                // reconnect'te guard erken return edip tab'ı kalıcı boş bırakır.)
+                this.isBootstrapping = false;
+            }
+            catch (err) {
+                console.error(`[boot:${_appName}] application bootstrap hatası:`, err);
+                this.isBootstrapping = false;
+                // sharedApp henüz set edilmediyse (createApplication başarısız) promise'ı sıfırla ki
+                // sonraki tab retry edebilsin — aksi halde rejected promise closure'da kalıcı kalır ve
+                // remote sayfa yenilemeden bir daha boot edilemez. (createComponent hatasında
+                // sharedAppRef zaten set'tir; o durumda promise korunur, app yeniden yaratılmaz.)
+                if (!sharedAppRef)
+                    sharedAppPromise = null;
+            }
+        }
+        disconnectedCallback() {
+            // Strategy hidden container ↔ view arası taşımalarda `removeChild` + `appendChild`
+            // ardışık olduğu için disconnectedCallback parent değişimiyle tetiklenir — element
+            // gerçekten destroy edilmiyor. `preserveWebComponentElement` öncesinde Strategy
+            // `__arilPreserveDuringDetach` flag'i set ediyor; o flag varsa view korunur.
+            const preserveFlag = this.__arilPreserveDuringDetach;
+            if (preserveFlag) {
+                return;
+            }
+            // Flag yok → gerçek destroy. Async re-connect ihtimaline karşı microtask sınırlı
+            // defansif gecikme; bir sonraki tick'te hâlâ disconnected mı diye son kontrol.
+            if (this.destroyTimer)
+                clearTimeout(this.destroyTimer);
+            this.destroyTimer = setTimeout(() => {
+                if (!this.isConnected && this.compRef) {
+                    console.log(`[boot:${_appName}] gerçek destroy → view + child injector destroy`);
+                    // Shared app'e ASLA dokunma; sadece bu tab'ın view'ını ve child injector'ını yık.
+                    if (sharedAppRef)
+                        sharedAppRef.detachView(this.compRef.hostView);
+                    this.compRef.destroy();
+                    this.childInjector?.destroy();
+                    this.compRef = null;
+                    this.childInjector = null;
+                    this.isBootstrapping = false;
+                }
+                this.destroyTimer = null;
+            }, 0);
+        }
+    }
+    try {
+        customElements.define(`app-${appName}`, MFEAppElement);
+    }
+    catch (e) {
+        if (e instanceof DOMException && e.name === 'NotSupportedError') {
+            console.warn(`[boot:${appName}] custom element zaten tanımlı, define atlandı`);
+            return;
+        }
+        throw e;
+    }
 };
 
 /**
  * Generated bundle index. Do not edit.
  */
 
-export { appName as a, menuItems as m };
+export { appName as a };
 //# sourceMappingURL=aril.mjs.map