aril 1.2.17 → 2.0.1-dev.0

package/esm2022/boot/config/apps/src/nav-link-context-menu.service.mjs

@@ -0,0 +1,105 @@
+import { Injectable, inject } from '@angular/core';
+import { TranslocoService } from '@ngneat/transloco';
+import { NavService } from './nav.service';
+import * as i0 from "@angular/core";
+/**
+ * Cross-injector singleton slot. `NavLinkContextMenuService` `providedIn: 'root'` olduğu
+ * için host ve her MFE remote'unda AYRI instance yaşar — `register(cm)` sadece host
+ * shell'de çağrılır, MFE'lerden gelen `open(...)` çağrıları kendi instance'ında `cm`
+ * bulamaz. Bu yüzden register sırasında host instance'ı global slot'a yazar; MFE
+ * instance'ları `cm` null ise bu slot üzerinden host'a delege eder.
+ *
+ * `bridge` modülündeki `__arilMfeBridge__` ile aynı pattern.
+ */
+const SLOT = '__arilNavLinkContextMenuOpen';
+const COMMAND_SLOT = '__arilNavCommand';
+/**
+ * Tab navigasyonu yapan tüm linkli yapılar için ortak sağ-tık context menu servisi.
+ * Tek bir global PrimeNG `ContextMenu` instance'ı host shell (`AppLayoutComponent`)
+ * template'inde yaşar; her sayfa kendi `ContextMenu` enstantiate etmek yerine bu
+ * service üzerinden `open(event, navItem)` çağırır.
+ *
+ * Servis hangi link tıklandıysa onun `NavItem`'iyle menü modelini yeniden inşa eder
+ * ve `cm.show(event)` ile açar — tüm tüketiciler için tek source-of-truth.
+ *
+ * **Kayıt sözleşmesi**: shell mount olunca `register(cm)` çağırır. MFE'lerden gelen
+ * çağrılar global slot üzerinden host'a delege edilir.
+ */
+export class NavLinkContextMenuService {
+    constructor() {
+        this.navService = inject(NavService);
+        this.translocoService = inject(TranslocoService);
+        this.cm = null;
+    }
+    register(cm) {
+        this.cm = cm;
+        // MFE'lerden gelen open çağrıları için cross-injector slot kur — bu instance'ın
+        // `openLocal`'ını sarmalayan bir function global slot'a yazılır.
+        const slotHost = globalThis;
+        slotHost[SLOT] = (event, navItem) => this.openLocal(event, navItem);
+        // Programatik "yeni tab aç ve geç" — MFE'lerden (eski `window.open('#'+url,'_blank')`
+        // yerine) host NavService'e delege için cross-injector slot.
+        slotHost[COMMAND_SLOT] = (navItem) => this.navService.openInNewTabAndFocus(navItem);
+    }
+    open(event, navItem) {
+        // Kendi cm'imiz varsa (host instance) doğrudan aç
+        if (this.cm) {
+            this.openLocal(event, navItem);
+            return;
+        }
+        // MFE instance: global slot üzerinden host'a delege
+        const slotHost = globalThis;
+        const hostOpen = slotHost[SLOT];
+        if (hostOpen) {
+            hostOpen(event, navItem);
+        }
+    }
+    /**
+     * Programatik "yeni tab aç ve geç" — MFE component'lerinden çağrılır (eski
+     * `window.open('#'+url,'_blank')` yerine). Host instance'ta (`cm` set) doğrudan
+     * `NavService.openInNewTabAndFocus`'u çağırır; MFE instance'ında `__arilNavCommand`
+     * global slot'u üzerinden host'a delege eder. Host shell henüz mount olmadıysa
+     * (slot boş) sessizce no-op olur.
+     */
+    openInNewTabAndFocus(navItem) {
+        if (this.cm) {
+            this.navService.openInNewTabAndFocus(navItem);
+            return;
+        }
+        const slotHost = globalThis;
+        const hostCommand = slotHost[COMMAND_SLOT];
+        if (hostCommand) {
+            hostCommand(navItem);
+        }
+    }
+    openLocal(event, navItem) {
+        if (!this.cm)
+            return;
+        const t = (key) => this.translocoService.translate(key);
+        this.cm.model = [
+            {
+                label: t('navLink.openHere'),
+                icon: 'pi pi-arrow-right',
+                command: () => this.navService.navigateInCurrentTab(navItem)
+            },
+            {
+                label: t('navLink.openInNewTab'),
+                icon: 'pi pi-external-link',
+                command: () => this.navService.openInBackgroundTab(navItem)
+            },
+            {
+                label: t('navLink.openInNewTabAndFocus'),
+                icon: 'pi pi-clone',
+                command: () => this.navService.openInNewTabAndFocus(navItem)
+            }
+        ];
+        this.cm.show(event);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.1.2", ngImport: i0, type: NavLinkContextMenuService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.1.2", ngImport: i0, type: NavLinkContextMenuService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.1.2", ngImport: i0, type: NavLinkContextMenuService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"nav-link-context-menu.service.js","sourceRoot":"","sources":["../../../../../../projects/aril/boot/config/apps/src/nav-link-context-menu.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable, inject } from '@angular/core';\r\n\r\nimport { ContextMenu } from 'primeng/contextmenu';\r\n\r\nimport { TranslocoService } from '@ngneat/transloco';\r\n\r\nimport { NavItem, NavService } from './nav.service';\r\n\r\n/**\r\n * Cross-injector singleton slot. `NavLinkContextMenuService` `providedIn: 'root'` olduğu\r\n * için host ve her MFE remote'unda AYRI instance yaşar — `register(cm)` sadece host\r\n * shell'de çağrılır, MFE'lerden gelen `open(...)` çağrıları kendi instance'ında `cm`\r\n * bulamaz. Bu yüzden register sırasında host instance'ı global slot'a yazar; MFE\r\n * instance'ları `cm` null ise bu slot üzerinden host'a delege eder.\r\n *\r\n * `bridge` modülündeki `__arilMfeBridge__` ile aynı pattern.\r\n */\r\nconst SLOT = '__arilNavLinkContextMenuOpen';\r\nconst COMMAND_SLOT = '__arilNavCommand';\r\ntype GlobalOpenFn = (event: MouseEvent, navItem: NavItem) => void;\r\ntype GlobalCommandFn = (navItem: NavItem) => void;\r\ntype GlobalSlotHost = { [SLOT]?: GlobalOpenFn; [COMMAND_SLOT]?: GlobalCommandFn };\r\n\r\n/**\r\n * Tab navigasyonu yapan tüm linkli yapılar için ortak sağ-tık context menu servisi.\r\n * Tek bir global PrimeNG `ContextMenu` instance'ı host shell (`AppLayoutComponent`)\r\n * template'inde yaşar; her sayfa kendi `ContextMenu` enstantiate etmek yerine bu\r\n * service üzerinden `open(event, navItem)` çağırır.\r\n *\r\n * Servis hangi link tıklandıysa onun `NavItem`'iyle menü modelini yeniden inşa eder\r\n * ve `cm.show(event)` ile açar — tüm tüketiciler için tek source-of-truth.\r\n *\r\n * **Kayıt sözleşmesi**: shell mount olunca `register(cm)` çağırır. MFE'lerden gelen\r\n * çağrılar global slot üzerinden host'a delege edilir.\r\n */\r\n@Injectable({ providedIn: 'root' })\r\nexport class NavLinkContextMenuService {\r\n\tprivate readonly navService = inject(NavService);\r\n\tprivate readonly translocoService = inject(TranslocoService);\r\n\tprivate cm: ContextMenu | null = null;\r\n\r\n\tregister(cm: ContextMenu): void {\r\n\t\tthis.cm = cm;\r\n\t\t// MFE'lerden gelen open çağrıları için cross-injector slot kur — bu instance'ın\r\n\t\t// `openLocal`'ını sarmalayan bir function global slot'a yazılır.\r\n\t\tconst slotHost = globalThis as unknown as GlobalSlotHost;\r\n\t\tslotHost[SLOT] = (event, navItem) => this.openLocal(event, navItem);\r\n\t\t// Programatik \"yeni tab aç ve geç\" — MFE'lerden (eski `window.open('#'+url,'_blank')`\r\n\t\t// yerine) host NavService'e delege için cross-injector slot.\r\n\t\tslotHost[COMMAND_SLOT] = (navItem) => this.navService.openInNewTabAndFocus(navItem);\r\n\t}\r\n\r\n\topen(event: MouseEvent, navItem: NavItem): void {\r\n\t\t// Kendi cm'imiz varsa (host instance) doğrudan aç\r\n\t\tif (this.cm) {\r\n\t\t\tthis.openLocal(event, navItem);\r\n\t\t\treturn;\r\n\t\t}\r\n\t\t// MFE instance: global slot üzerinden host'a delege\r\n\t\tconst slotHost = globalThis as unknown as GlobalSlotHost;\r\n\t\tconst hostOpen = slotHost[SLOT];\r\n\t\tif (hostOpen) {\r\n\t\t\thostOpen(event, navItem);\r\n\t\t}\r\n\t}\r\n\r\n\t/**\r\n\t * Programatik \"yeni tab aç ve geç\" — MFE component'lerinden çağrılır (eski\r\n\t * `window.open('#'+url,'_blank')` yerine). Host instance'ta (`cm` set) doğrudan\r\n\t * `NavService.openInNewTabAndFocus`'u çağırır; MFE instance'ında `__arilNavCommand`\r\n\t * global slot'u üzerinden host'a delege eder. Host shell henüz mount olmadıysa\r\n\t * (slot boş) sessizce no-op olur.\r\n\t */\r\n\topenInNewTabAndFocus(navItem: NavItem): void {\r\n\t\tif (this.cm) {\r\n\t\t\tthis.navService.openInNewTabAndFocus(navItem);\r\n\t\t\treturn;\r\n\t\t}\r\n\t\tconst slotHost = globalThis as unknown as GlobalSlotHost;\r\n\t\tconst hostCommand = slotHost[COMMAND_SLOT];\r\n\t\tif (hostCommand) {\r\n\t\t\thostCommand(navItem);\r\n\t\t}\r\n\t}\r\n\r\n\tprivate openLocal(event: MouseEvent, navItem: NavItem): void {\r\n\t\tif (!this.cm) return;\r\n\t\tconst t = (key: string): string => this.translocoService.translate(key);\r\n\t\tthis.cm.model = [\r\n\t\t\t{\r\n\t\t\t\tlabel: t('navLink.openHere'),\r\n\t\t\t\ticon: 'pi pi-arrow-right',\r\n\t\t\t\tcommand: () => this.navService.navigateInCurrentTab(navItem)\r\n\t\t\t},\r\n\t\t\t{\r\n\t\t\t\tlabel: t('navLink.openInNewTab'),\r\n\t\t\t\ticon: 'pi pi-external-link',\r\n\t\t\t\tcommand: () => this.navService.openInBackgroundTab(navItem)\r\n\t\t\t},\r\n\t\t\t{\r\n\t\t\t\tlabel: t('navLink.openInNewTabAndFocus'),\r\n\t\t\t\ticon: 'pi pi-clone',\r\n\t\t\t\tcommand: () => this.navService.openInNewTabAndFocus(navItem)\r\n\t\t\t}\r\n\t\t];\r\n\t\tthis.cm.show(event);\r\n\t}\r\n}\r\n"]}

package/esm2022/boot/config/apps/src/nav-link.directive.mjs

@@ -0,0 +1,45 @@
+import { Directive, HostListener, Input, inject } from '@angular/core';
+import { NavLinkContextMenuService } from './nav-link-context-menu.service';
+import * as i0 from "@angular/core";
+/**
+ * Linkli her HTML elementine sağ-tık → tab context menüsü ekleyen directive.
+ *
+ * **Kullanım**: navLink/navName (ve opsiyonel icon) bilgisini object literal olarak verin:
+ * ```html
+ * <a [attr.href]="'#/' + path"
+ *    [arilNavLink]="{ tabId: '', navLink: path, navName: 'Sayfa Adı', icon: 'pi pi-cog' }"
+ *    (click)="...">
+ * ```
+ *
+ * Sağ tık → "Bu sekmede aç / Yeni sekmede aç / Yeni sekmede aç ve geç" menüsü açılır;
+ * komutlar `NavService` üzerinden ilgili tab eylemini tetikler. Ctrl+Click / Middle Click
+ * gibi mevcut shortcut'lar değişmez — bu menü onlara klavye/fare bilgisi olmayan
+ * kullanıcılar için keşfedilebilir bir alternatif.
+ */
+export class NavLinkDirective {
+    constructor() {
+        this.contextMenuService = inject(NavLinkContextMenuService);
+    }
+    onContextMenu(event) {
+        if (!this.navItem?.navLink)
+            return;
+        event.preventDefault();
+        this.contextMenuService.open(event, this.navItem);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.1.2", ngImport: i0, type: NavLinkDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "17.1.2", type: NavLinkDirective, isStandalone: true, selector: "[arilNavLink]", inputs: { navItem: ["arilNavLink", "navItem"] }, host: { listeners: { "contextmenu": "onContextMenu($event)" } }, ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.1.2", ngImport: i0, type: NavLinkDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    standalone: true,
+                    selector: '[arilNavLink]'
+                }]
+        }], propDecorators: { navItem: [{
+                type: Input,
+                args: ['arilNavLink']
+            }], onContextMenu: [{
+                type: HostListener,
+                args: ['contextmenu', ['$event']]
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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