aril 1.2.18 → 2.0.1-dev.0

package/fesm2022/aril-boot-mfe-aril-boot-mfe-KFO_X7yR.mjs

@@ -0,0 +1,631 @@
+import { LocationStrategy, Location } from '@angular/common';
+import { HttpClient } from '@angular/common/http';
+import * as i0 from '@angular/core';
+import { Injectable, APP_INITIALIZER, importProvidersFrom, ɵINJECTOR_SCOPE as _INJECTOR_SCOPE, ApplicationRef, createEnvironmentInjector, isDevMode, createComponent } from '@angular/core';
+import { createApplication } from '@angular/platform-browser';
+import { provideRouter, withComponentInputBinding, withRouterConfig, RouteReuseStrategy, UrlSerializer, Router } from '@angular/router';
+import { PrimeNGConfig, MessageService, ConfirmationService } from 'primeng/api';
+import { TranslocoService } from '@ngneat/transloco';
+import { KeycloakService } from 'keycloak-angular';
+import { MonacoEditorModule, NGX_MONACO_EDITOR_CONFIG } from 'ngx-monaco-editor-v2';
+import { createBaseAppConfig } from 'aril/boot/base';
+import { setApiConfigOnMFEMode } from 'aril/boot/config/api';
+import { CustomRouteReuseStrategy, TabAwareUrlSerializer } from 'aril/boot/config/apps';
+import { getNgZone, loadPlugins } from 'aril/boot/config/plugins';
+import { i18nFolderName } from 'aril/i18n';
+import { provideHost } from 'aril/provider';
+import { PubSubService } from 'aril/util/pub-sub';
+
+const appComponentLoader = async () => {
+    const { AppComponent } = await import('./aril-boot-mfe-app.component-a34GeuUv.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 },
+    onMonacoLoad: () => {
+        // JSON düzenleyici ayarları
+        if (monaco && monaco.languages && monaco.languages.json) {
+            monaco.languages.json.jsonDefaults.setDiagnosticsOptions({
+                validate: true,
+                allowComments: false,
+                schemas: []
+            });
+        }
+        // JavaScript/TypeScript düzenleyici ayarları
+        if (monaco && monaco.languages && monaco.languages.typescript) {
+            monaco.languages.typescript.javascriptDefaults.setCompilerOptions({
+                target: monaco.languages.typescript.ScriptTarget.ES2016,
+                allowNonTsExtensions: true,
+                moduleResolution: monaco.languages.typescript.ModuleResolutionKind.NodeJs,
+                module: monaco.languages.typescript.ModuleKind.CommonJS,
+                noEmit: true,
+                typeRoots: ['node_modules/@types']
+            });
+            // TypeScript düzenleyici ayarları
+            monaco.languages.typescript.typescriptDefaults.setCompilerOptions({
+                target: monaco.languages.typescript.ScriptTarget.ES2016,
+                allowNonTsExtensions: true,
+                moduleResolution: monaco.languages.typescript.ModuleResolutionKind.NodeJs,
+                module: monaco.languages.typescript.ModuleKind.CommonJS,
+                noEmit: true,
+                typeRoots: ['node_modules/@types']
+            });
+        }
+        // HTML, XML ve diğer markup dilleri için ayarlar
+        if (monaco && monaco.languages && monaco.languages.html) {
+            monaco.languages.html.htmlDefaults.setOptions({
+                format: {
+                    tabSize: 2,
+                    insertSpaces: true
+                },
+                suggest: {
+                    html5: true
+                }
+            });
+        }
+        // Python için syntax highlighting ve özel formatlamalar
+        if (monaco && monaco.languages) {
+            monaco.languages.registerDocumentFormattingEditProvider('python', {
+                provideDocumentFormattingEdits: function (model) {
+                    const text = model.getValue();
+                    return [
+                        {
+                            range: model.getFullModelRange(),
+                            text: text
+                        }
+                    ];
+                }
+            });
+            // Python için özel linting kuralları
+            monaco.languages.registerCompletionItemProvider('python', {
+                provideCompletionItems: function (model, position) {
+                    const suggestions = [
+                        {
+                            label: 'def',
+                            kind: monaco.languages.CompletionItemKind.Keyword,
+                            insertText: 'def ${1:function_name}(${2:parameters}):\n\t${3:pass}',
+                            insertTextRules: monaco.languages.CompletionItemInsertTextRule.InsertAsSnippet,
+                            documentation: 'Fonksiyon tanımlama'
+                        },
+                        {
+                            label: 'class',
+                            kind: monaco.languages.CompletionItemKind.Keyword,
+                            insertText: 'class ${1:ClassName}:\n\tdef __init__(self, ${2:parameters}):\n\t\t${3:pass}',
+                            insertTextRules: monaco.languages.CompletionItemInsertTextRule.InsertAsSnippet,
+                            documentation: 'Sınıf tanımlama'
+                        },
+                        {
+                            label: 'if',
+                            kind: monaco.languages.CompletionItemKind.Keyword,
+                            insertText: 'if ${1:condition}:\n\t${2:pass}',
+                            insertTextRules: monaco.languages.CompletionItemInsertTextRule.InsertAsSnippet,
+                            documentation: 'If bloğu'
+                        },
+                        {
+                            label: 'for',
+                            kind: monaco.languages.CompletionItemKind.Keyword,
+                            insertText: 'for ${1:item} in ${2:iterable}:\n\t${3:pass}',
+                            insertTextRules: monaco.languages.CompletionItemInsertTextRule.InsertAsSnippet,
+                            documentation: 'For döngüsü'
+                        }
+                    ];
+                    return { suggestions: suggestions };
+                }
+            });
+        }
+        // Lua için özel ayarlar
+        if (monaco && monaco.languages) {
+            monaco.languages.registerDocumentFormattingEditProvider('lua', {
+                provideDocumentFormattingEdits: function (model) {
+                    const text = model.getValue();
+                    return [
+                        {
+                            range: model.getFullModelRange(),
+                            text: text
+                        }
+                    ];
+                }
+            });
+            monaco.languages.registerCompletionItemProvider('lua', {
+                provideCompletionItems: function (model, position) {
+                    const suggestions = [
+                        {
+                            label: 'function',
+                            kind: monaco.languages.CompletionItemKind.Keyword,
+                            insertText: 'function ${1:name}(${2:params})\n\t${3:-- body}\nend',
+                            insertTextRules: monaco.languages.CompletionItemInsertTextRule.InsertAsSnippet,
+                            documentation: 'Fonksiyon tanımlama'
+                        },
+                        {
+                            label: 'if',
+                            kind: monaco.languages.CompletionItemKind.Keyword,
+                            insertText: 'if ${1:condition} then\n\t${2:-- body}\nend',
+                            insertTextRules: monaco.languages.CompletionItemInsertTextRule.InsertAsSnippet,
+                            documentation: 'If bloğu'
+                        },
+                        {
+                            label: 'for',
+                            kind: monaco.languages.CompletionItemKind.Keyword,
+                            insertText: 'for ${1:i}=${2:1},${3:10} do\n\t${4:-- body}\nend',
+                            insertTextRules: monaco.languages.CompletionItemInsertTextRule.InsertAsSnippet,
+                            documentation: 'For döngüsü'
+                        }
+                    ];
+                    return { suggestions: suggestions };
+                }
+            });
+        }
+        // Java için özel ayarlar
+        if (monaco && monaco.languages) {
+            monaco.languages.registerDocumentFormattingEditProvider('java', {
+                provideDocumentFormattingEdits: function (model) {
+                    const text = model.getValue();
+                    // Java formatlaması
+                    return [
+                        {
+                            range: model.getFullModelRange(),
+                            text: text // Formatlanmış metin
+                        }
+                    ];
+                }
+            });
+            // Java için özel öneriler
+            monaco.languages.registerCompletionItemProvider('java', {
+                provideCompletionItems: function (model, position) {
+                    const suggestions = [
+                        {
+                            label: 'class',
+                            kind: monaco.languages.CompletionItemKind.Keyword,
+                            insertText: 'public class ${1:ClassName} {\n\t${2}\n}',
+                            insertTextRules: monaco.languages.CompletionItemInsertTextRule.InsertAsSnippet,
+                            documentation: 'Sınıf tanımlama'
+                        },
+                        {
+                            label: 'main',
+                            kind: monaco.languages.CompletionItemKind.Snippet,
+                            insertText: 'public static void main(String[] args) {\n\t${1}\n}',
+                            insertTextRules: monaco.languages.CompletionItemInsertTextRule.InsertAsSnippet,
+                            documentation: 'Main metodu'
+                        },
+                        {
+                            label: 'sout',
+                            kind: monaco.languages.CompletionItemKind.Snippet,
+                            insertText: 'System.out.println(${1});',
+                            insertTextRules: monaco.languages.CompletionItemInsertTextRule.InsertAsSnippet,
+                            documentation: 'Konsola yazdırma'
+                        }
+                    ];
+                    return { suggestions: suggestions };
+                }
+            });
+        }
+        // HTML için özel ayarlar
+        if (monaco && monaco.languages) {
+            monaco.languages.registerCompletionItemProvider('html', {
+                provideCompletionItems: function (model, position) {
+                    const suggestions = [
+                        {
+                            label: 'html5',
+                            kind: monaco.languages.CompletionItemKind.Snippet,
+                            insertText: '<!DOCTYPE html>\n<html lang="en">\n<head>\n\t<meta charset="UTF-8">\n\t<meta name="viewport" content="width=device-width, initial-scale=1.0">\n\t<title>${1:Document}</title>\n</head>\n<body>\n\t${2}\n</body>\n</html>',
+                            insertTextRules: monaco.languages.CompletionItemInsertTextRule.InsertAsSnippet,
+                            documentation: 'HTML5 taslağı'
+                        },
+                        {
+                            label: 'div',
+                            kind: monaco.languages.CompletionItemKind.Snippet,
+                            insertText: '<div class="${1:className}">\n\t${2}\n</div>',
+                            insertTextRules: monaco.languages.CompletionItemInsertTextRule.InsertAsSnippet,
+                            documentation: 'Div elementi'
+                        }
+                    ];
+                    return { suggestions: suggestions };
+                }
+            });
+        }
+        // XML için özel ayarlar
+        if (monaco && monaco.languages) {
+            monaco.languages.registerCompletionItemProvider('xml', {
+                provideCompletionItems: function (model, position) {
+                    const suggestions = [
+                        {
+                            label: 'xml',
+                            kind: monaco.languages.CompletionItemKind.Snippet,
+                            insertText: '<?xml version="1.0" encoding="UTF-8"?>\n<${1:root}>\n\t${2}\n</${1:root}>',
+                            insertTextRules: monaco.languages.CompletionItemInsertTextRule.InsertAsSnippet,
+                            documentation: 'XML taslağı'
+                        }
+                    ];
+                    return { suggestions: suggestions };
+                }
+            });
+        }
+        // JSON için özel ayarlar ve şema doğrulama
+        if (monaco && monaco.languages && monaco.languages.json) {
+            monaco.languages.json.jsonDefaults.setDiagnosticsOptions({
+                validate: true,
+                allowComments: false,
+                schemas: [
+                    {
+                        uri: 'http://myserver/schema/package.schema.json',
+                        fileMatch: ['package.json'],
+                        schema: {
+                            type: 'object',
+                            properties: {
+                                name: { type: 'string' },
+                                version: { type: 'string' },
+                                dependencies: {
+                                    type: 'object'
+                                }
+                            }
+                        }
+                    }
+                ]
+            });
+        }
+    }
+};
+
+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 (bootedApps.has(_appName) || customElements.get(`app-${_appName}`))
+        return;
+    bootedApps.add(_appName);
+    appName = _appName;
+    menuItems = _menuItems;
+    /**
+     * **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),
+            getNgZone(),
+            {
+                provide: APP_INITIALIZER,
+                useFactory: (httpClient, keycloak, folderName) => {
+                    const runApiInit = setApiConfigOnMFEMode(httpClient, keycloak, folderName);
+                    const runLoadPlugins = loadPlugins();
+                    return async () => {
+                        await runApiInit();
+                        runLoadPlugins();
+                    };
+                },
+                multi: true,
+                deps: [HttpClient, KeycloakService, i18nFolderName]
+            },
+            importProvidersFrom(MonacoEditorModule.forRoot()),
+            { provide: NGX_MONACO_EDITOR_CONFIG, useValue: monacoConfig }
+        ]
+    };
+    /**
+     * 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, boot as b };
+//# sourceMappingURL=aril-boot-mfe-aril-boot-mfe-KFO_X7yR.mjs.map