aril 2.0.1-dev.3 → 2.0.1-dev.4

package/fesm2022/aril-theme-layout.mjs

@@ -3468,7 +3468,12 @@ class BreadcrumbPublisherService {
             // değerleri sonradan geldikçe listeyi yeniden yayınla.
             this.breadcrumbService.keyValues();
             this.publishFromCurrentRoute();
-        });
+        }, 
+        // `publishFromCurrentRoute` → `publish` içinde `bridge.breadcrumbs.set` / `bridge.pageTitle.set`
+        // signal write yapar; effect içinden signal write default'ta NG0600 fırlatır. aril genelindeki
+        // effect'lerle aynı şekilde `allowSignalWrites` ile izin veriyoruz. (MF shared core öncesi
+        // cross-core split bu guard'ı maskeliyordu; tek core olunca yüzeye çıktı — davranış aynı.)
+        { allowSignalWrites: true });
     }
     ngOnDestroy() {
         this.routerSubscription?.unsubscribe();
@@ -3503,7 +3508,10 @@ class BreadcrumbPublisherService {
     publish(breadcrumbs) {
         bridge.breadcrumbs.set(breadcrumbs);
         const lastLabel = breadcrumbs[breadcrumbs.length - 1]?.label ?? '';
-        if (bridge.pageTitle() || lastLabel) {
+        // untracked ZORUNLU: publish, constructor'daki effect'in çağrı grafiğinde çalışır. Tracked
+        // okuma effect'i kendi yazdığı pageTitle'a abone eder; tab başına bir publisher instance
+        // olduğundan iki tab farklı title yazarak birbirini sonsuz döngüde tetiklerdi.
+        if (untracked(bridge.pageTitle) || lastLabel) {
             bridge.pageTitle.set(lastLabel);
         }
         this.pubSubService.publish({
@@ -3562,34 +3570,148 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.1.2", ngImpor
                 }]
         }], ctorParameters: () => [] });
 
+// Key başına maksimum ardışık fetch hatası: limit aşılınca o key oturum boyu yeniden denenmez.
+// Sınırsız retry'da kalıcı hata veren bir grup (örn. silinmiş grup → 404), diğer grupların her
+// başarılı yüklemesinde (map güncellemesi tüm enum computed'larını yeniden çalıştırır) yeniden
+// POST edilirdi → istek/console fırtınası.
+const MAX_FETCH_FAILURES = 3;
 class SelectionGroupService {
     constructor(http) {
         this.http = http;
-        this.selectionGroups = signal({});
-        this.loading = new Map();
-        this.loaded = new Map();
-        this.loadStatesFromLocalStorage();
-        effect(() => {
-            const encodedData = btoa(encodeURI(JSON.stringify(this.selectionGroups())));
-            localStorage.setItem('selection-groups', encodedData);
-        });
+        // State cross-MFE paylaşımlı: bridge globalThis-singleton'ında yaşar (bkz. mfe-bridge.ts).
+        // Servis instance'ı MFE/tab başına çoğalsa da tüm okuma/yazma tek bridge state'ine gider.
+        this.selectionGroups = bridge.selectionGroups;
+        this.loading = bridge.selectionLoading;
+        this.loaded = bridge.selectionLoaded;
+        this.failures = bridge.selectionFailures;
+        // loadStates + invalidate yalnızca ilk instance'ta (cross-MFE bir kez): tek localStorage
+        // yüklemesi, tek `/versions` çağrısı. effect her instance'ta kurulur ama hepsi aynı paylaşılan
+        // state'i yazdığından ezme olmaz.
+        if (!bridge.selectionInitialized) {
+            bridge.selectionInitialized = true;
+            this.loadStatesFromLocalStorage();
+            this.invalidateStaleGroups();
+        }
+    }
+    // localStorage'a slim cache yazar. `effect` YERİNE bilinçli olarak doğrudan çağrılır: signal'i
+    // değiştiren her yer (fetchEnum, invalidateStaleGroups) persist'i açıkça tetikler. NOT: webpack MF
+    // config'iyle `@angular/core` artık singleton shared olduğundan effect-tabanlı persist de çalışırdı;
+    // yine de açık/öngörülebilir olması (effect içinde gizli signal-write + NG0600 riski olmaması) için
+    // doğrudan çağrı tercih edildi.
+    persistToLocalStorage() {
+        try {
+            const slim = this.slimForStorage(this.selectionGroups());
+            localStorage.setItem('selection-groups', btoa(encodeURI(JSON.stringify(slim))));
+        }
+        catch {
+            // QuotaExceededError vb. → eski cache'i koru, yeni yazımı sessizce atla.
+        }
     }
-    async loadStatesFromLocalStorage() {
+    loadStatesFromLocalStorage() {
         const selectionGroups = localStorage.getItem('selection-groups');
         if (selectionGroups) {
             try {
                 const decodedData = decodeURI(atob(selectionGroups));
-                this.selectionGroups.set(JSON.parse(decodedData));
+                // Dynamic gruplar zaten persist edilmiyor (slimForStorage onları atlar) → ekstra
+                // filtre gerekmez; localStorage içeriği yalnızca Fixed gruplardır.
+                const restored = JSON.parse(decodedData);
+                this.selectionGroups.set(restored);
+                // Restore edilen gruplar loaded sayılır: aksi halde koşulsuz fetchEnum çağıran
+                // consumer'lar guard'ı geçip her oturum yeniden çeker (cache faydası kaybolur).
+                // Stale'lik kontrolü invalidateStaleGroups'un işi. null entry'ler (legacy) loaded
+                // işaretlenmez — işaretlenirse o grup bir daha hiç yüklenemezdi.
+                Object.entries(restored).forEach(([key, group]) => {
+                    if (group)
+                        this.loaded.set(key, true);
+                });
             }
             catch (e) {
                 console.error(e);
             }
         }
     }
+    // Dynamic grupları atlar + Fixed grupları yalnızca render (value/table/picker/export) ve invalidate
+    // için gerekli alanlara indirger. localStorage'da audit/id/açıklama gibi kullanılmayan alanları tutmaz.
+    slimForStorage(groups) {
+        const out = {};
+        for (const [key, group] of Object.entries(groups)) {
+            if (!group || group.loadStrategy === 'Dynamic')
+                continue;
+            out[key] = {
+                version: group.version,
+                selectionItems: (group.selectionItems ?? []).map((it) => ({
+                    selectionKey: it.selectionKey,
+                    selectionDisplay: it.selectionDisplay,
+                    selectionMultiLanguageDisplays: it.selectionMultiLanguageDisplays,
+                    showOrder: it.showOrder,
+                    parentSelectionKey: it.parentSelectionKey
+                }))
+            };
+        }
+        return out;
+    }
+    // App init'te enum version'larını çekip localStorage'daki stale grupları temizler.
+    // Silinen grup, tüketici component'lerin `if (!selectionGroup) fetchEnum()` guard'ıyla yeniden yüklenir.
+    invalidateStaleGroups() {
+        // App-init snapshot: yalnızca localStorage'dan yüklenen gruplar kontrol edilir. Yanıt gelene
+        // kadar consumer'ların fetchEnum ile yüklediği taze gruplar taranmaz/silinmez (aksi halde
+        // taze grup silinir ve kalıcı per-component fetch guard'ları onu bir daha çekmeyebilir).
+        const keysToCheck = Object.keys(this.selectionGroups());
+        if (keysToCheck.length === 0)
+            return;
+        const hostApi = API_CONFIGS.api.replace(/\/[^\/]+\/v1$/, `/host/v1`);
+        this.http
+            .get(hostApi + '/selection-group/versions')
+            .pipe(take(1))
+            .subscribe({
+            next: (versions) => {
+                // Boş/bozuk yanıt güvenlik şeridi: aşağıdaki "listede olmayanı sil" kuralı
+                // boş listeyle tüm cache'i yanlışlıkla boşaltmasın.
+                if (!versions?.length)
+                    return;
+                const latest = new Map(versions.map((v) => [v.groupName, v.version]));
+                let changed = false;
+                const next = { ...this.selectionGroups() };
+                keysToCheck.forEach((key) => {
+                    const group = next[key];
+                    if (!group)
+                        return;
+                    const separatorIndex = key.indexOf('~');
+                    if (separatorIndex === -1)
+                        return;
+                    const serverVersion = latest.get(key.substring(0, separatorIndex));
+                    // serverVersion == null: grup /versions listesinde yok → sunucudan silinmiş /
+                    // yeniden adlandırılmış demektir (endpoint Fixed grupların tam listesini döner)
+                    // → o da evict edilir; kalırsa kaldırılmış enum değerleri süresiz render edilir.
+                    if (serverVersion == null || serverVersion !== group.version) {
+                        delete next[key];
+                        this.loaded.delete(key);
+                        this.failures.delete(key);
+                        // Uçuştaki fetch'in flag'i korunur: silinirse ikinci bir consumer guard'ı
+                        // geçip duplicate /load atar ve export-overlay'in isLoading poll'ü grubu
+                        // beklemeden erken geçer. Yanıt geldiğinde flag'i fetchEnum kendisi yönetir.
+                        if (!this.loading.get(key)) {
+                            this.loading.delete(key);
+                        }
+                        changed = true;
+                    }
+                });
+                if (changed) {
+                    this.selectionGroups.set(next);
+                    this.persistToLocalStorage();
+                }
+            },
+            error: () => {
+                // versions endpoint yok/erişilemez: sessizce mevcut cache ile devam.
+            }
+        });
+    }
     fetchEnum(groupName, parentSelectionKey = 'ALL') {
         const key = groupName + '~' + parentSelectionKey;
         if (this.loaded.get(key) || this.loading.get(key))
             return;
+        if ((this.failures.get(key) ?? 0) >= MAX_FETCH_FAILURES)
+            return;
         const payload = {
             groupName,
             parentSelectionKey
@@ -3600,17 +3722,32 @@ class SelectionGroupService {
         this.http
             .post(hostApi + '/selection-group/load', payload)
             .pipe(take(1))
-            .subscribe((selectionGroup) => {
-            this.loading.set(key, false);
-            this.loaded.set(key, true);
-            this.selectionGroups.update((groups) => ({
-                ...groups,
-                [key]: selectionGroup
-            }));
+            .subscribe({
+            next: (selectionGroup) => {
+                this.loading.set(key, false);
+                this.loaded.set(key, true);
+                this.failures.delete(key);
+                this.selectionGroups.update((groups) => ({
+                    ...groups,
+                    [key]: selectionGroup
+                }));
+                this.persistToLocalStorage();
+            },
+            // HTTP hatasında loading'i sıfırla: aksi halde guard (loaded/loading) bu enum'u
+            // kilitler. loading/loaded bridge'de cross-MFE SHARED olduğundan, tek bir anlık hata
+            // bu enum'u TÜM remote'larda hard-reload'a kadar bir daha çekilemez yapardı. loading=false
+            // → sonraki fetchEnum (component init/retry) yeniden deneyebilir. loaded zaten false kalır.
+            // Deneme sayısı MAX_FETCH_FAILURES ile sınırlı: kalıcı hatada sonsuz retry önlenir.
+            error: () => {
+                this.loading.set(key, false);
+                this.failures.set(key, (this.failures.get(key) ?? 0) + 1);
+            }
         });
     }
-    isLoading(groupName) {
-        return this.loading.get(groupName) ?? false;
+    // key formatı: `groupName~parentSelectionKey` (fetchEnum'daki composite key ile aynı).
+    // Direkt olarak groupName geçilirse Map'te eşleşme olmaz ve her zaman false döner.
+    isLoading(key) {
+        return this.loading.get(key) ?? false;
     }
     static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.1.2", ngImport: i0, type: SelectionGroupService, deps: [{ token: i6.HttpClient }], target: i0.ɵɵFactoryTarget.Injectable }); }
     static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.1.2", ngImport: i0, type: SelectionGroupService, providedIn: 'root' }); }