@alfresco/aca-content 5.1.1 → 5.2.0

package/esm2022/lib/services/node-template.service.mjs

@@ -0,0 +1,145 @@
+/*!
+ * Copyright © 2005-2024 Hyland Software, Inc. and its affiliates. All rights reserved.
+ *
+ * Alfresco Example Content Application
+ *
+ * This file is part of the Alfresco Example Content Application.
+ * If the software was purchased under a paid Alfresco license, the terms of
+ * the paid license agreement will prevail. Otherwise, the software is
+ * provided under the following open source license terms:
+ *
+ * The Alfresco Example Content Application is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * The Alfresco Example Content Application is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * from Hyland Software. If not, see <http://www.gnu.org/licenses/>.
+ */
+import { inject, Injectable } from '@angular/core';
+import { MatDialog } from '@angular/material/dialog';
+import { CreateFromTemplateDialogComponent } from '../dialogs/node-template/create-from-template.dialog';
+import { Subject, from, of } from 'rxjs';
+import { SearchApi } from '@alfresco/js-api';
+import { TranslationService, NotificationService } from '@alfresco/adf-core';
+import { switchMap, catchError } from 'rxjs/operators';
+import { AlfrescoApiService, ContentNodeSelectorComponent, NodeAction } from '@alfresco/adf-content-services';
+import * as i0 from "@angular/core";
+class NodeTemplateService {
+    alfrescoApiService = inject(AlfrescoApiService);
+    notificationService = inject(NotificationService);
+    translation = inject(TranslationService);
+    dialog = inject(MatDialog);
+    currentTemplateConfig = null;
+    rootNode;
+    _searchApi;
+    get searchApi() {
+        this._searchApi = this._searchApi ?? new SearchApi(this.alfrescoApiService.getInstance());
+        return this._searchApi;
+    }
+    selectTemplateDialog(config) {
+        this.currentTemplateConfig = config;
+        const select = new Subject();
+        select.subscribe({
+            complete: this.close.bind(this)
+        });
+        const data = {
+            selectionMode: 'single',
+            title: this.title(config.selectionType),
+            actionName: NodeAction.NEXT,
+            dropdownHideMyFiles: true,
+            currentFolderId: null,
+            dropdownSiteList: null,
+            breadcrumbTransform: this.transformNode.bind(this),
+            select,
+            showSearch: false,
+            showDropdownSiteList: false,
+            isSelectionValid: this.isSelectionValid.bind(this),
+            rowFilter: this.rowFilter.bind(this)
+        };
+        const query = {
+            query: {
+                query: `PATH:"//${config.primaryPathName}"`,
+                language: 'afts'
+            },
+            include: ['path', 'properties', 'allowableOperations', 'permissions']
+        };
+        from(this.searchApi.search(query))
+            .pipe(switchMap((response) => {
+            const entry = response.list.entries[0].entry;
+            this.rootNode = entry;
+            data.currentFolderId = entry.id;
+            return this.dialog
+                .open(ContentNodeSelectorComponent, {
+                data,
+                panelClass: ['adf-content-node-selector-dialog', 'aca-template-node-selector-dialog'],
+                width: '630px'
+            })
+                .afterClosed();
+        }), catchError((error) => {
+            this.notificationService.showError('APP.MESSAGES.ERRORS.GENERIC');
+            return of(error);
+        }))
+            .subscribe({ next: () => select.complete() });
+        return select;
+    }
+    createTemplateDialog(node) {
+        const dialog = this.dialog.open(CreateFromTemplateDialogComponent, {
+            data: node,
+            panelClass: 'aca-create-from-template-dialog',
+            width: '630px'
+        });
+        dialog.afterClosed().subscribe(() => this.focusCreateMenuButton());
+        return dialog;
+    }
+    transformNode(node) {
+        if (node?.path?.elements instanceof Array) {
+            node.path.elements = this.getPathElements(node);
+        }
+        return node;
+    }
+    isSelectionValid(node) {
+        if (!node.path.elements.length) {
+            return false;
+        }
+        if (this.currentTemplateConfig.selectionType === 'folder') {
+            return node.isFolder;
+        }
+        return node.isFile;
+    }
+    close() {
+        this.dialog.closeAll();
+        this.focusCreateMenuButton();
+    }
+    title(selectionType) {
+        if (selectionType === 'file') {
+            return this.translation.instant('NODE_SELECTOR.SELECT_FILE_TEMPLATE_TITLE');
+        }
+        return this.translation.instant('NODE_SELECTOR.SELECT_FOLDER_TEMPLATE_TITLE');
+    }
+    rowFilter(row) {
+        const node = row.node.entry;
+        return node.nodeType !== 'app:filelink' && node.nodeType !== 'app:folderlink';
+    }
+    getPathElements(node) {
+        return node.path.elements.filter((pathElement) => !this.rootNode.path.elements.some((rootPathElement) => pathElement.id === rootPathElement.id));
+    }
+    focusCreateMenuButton() {
+        document.querySelector('app-toolbar-menu button[id="app.toolbar.create"]').focus();
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.9", ngImport: i0, type: NodeTemplateService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.2.9", ngImport: i0, type: NodeTemplateService, providedIn: 'root' });
+}
+export { NodeTemplateService };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.9", ngImport: i0, type: NodeTemplateService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"node-template.service.js","sourceRoot":"","sources":["../../../../../../projects/aca-content/src/lib/services/node-template.service.ts"],"names":[],"mappings":"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","sourcesContent":["/*!\n * Copyright © 2005-2024 Hyland Software, Inc. and its affiliates. All rights reserved.\n *\n * Alfresco Example Content Application\n *\n * This file is part of the Alfresco Example Content Application.\n * If the software was purchased under a paid Alfresco license, the terms of\n * the paid license agreement will prevail. Otherwise, the software is\n * provided under the following open source license terms:\n *\n * The Alfresco Example Content Application is free software: you can redistribute it and/or modify\n * it under the terms of the GNU Lesser General Public License as published by\n * the Free Software Foundation, either version 3 of the License, or\n * (at your option) any later version.\n *\n * The Alfresco Example Content Application is distributed in the hope that it will be useful,\n * but WITHOUT ANY WARRANTY; without even the implied warranty of\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\n * GNU Lesser General Public License for more details.\n *\n * You should have received a copy of the GNU Lesser General Public License\n * from Hyland Software. If not, see <http://www.gnu.org/licenses/>.\n */\n\nimport { inject, Injectable } from '@angular/core';\nimport { MatDialog, MatDialogRef } from '@angular/material/dialog';\nimport { CreateFromTemplateDialogComponent } from '../dialogs/node-template/create-from-template.dialog';\nimport { Subject, from, of } from 'rxjs';\nimport { Node, ResultNode, PathElement, SearchApi } from '@alfresco/js-api';\nimport { TranslationService, NotificationService } from '@alfresco/adf-core';\nimport { switchMap, catchError } from 'rxjs/operators';\nimport {\n  AlfrescoApiService,\n  ContentNodeSelectorComponent,\n  ContentNodeSelectorComponentData,\n  ShareDataRow,\n  NodeAction\n} from '@alfresco/adf-content-services';\n\nexport interface TemplateDialogConfig {\n  primaryPathName: string;\n  selectionType: string;\n}\n\n@Injectable({\n  providedIn: 'root'\n})\nexport class NodeTemplateService {\n  private alfrescoApiService = inject(AlfrescoApiService);\n  private notificationService = inject(NotificationService);\n  private translation = inject(TranslationService);\n  private dialog = inject(MatDialog);\n\n  private currentTemplateConfig: TemplateDialogConfig = null;\n  private rootNode: ResultNode;\n\n  private _searchApi: SearchApi;\n  get searchApi(): SearchApi {\n    this._searchApi = this._searchApi ?? new SearchApi(this.alfrescoApiService.getInstance());\n    return this._searchApi;\n  }\n\n  selectTemplateDialog(config: TemplateDialogConfig): Subject<Node[]> {\n    this.currentTemplateConfig = config;\n\n    const select = new Subject<Node[]>();\n    select.subscribe({\n      complete: this.close.bind(this)\n    });\n\n    const data: ContentNodeSelectorComponentData = {\n      selectionMode: 'single',\n      title: this.title(config.selectionType),\n      actionName: NodeAction.NEXT,\n      dropdownHideMyFiles: true,\n      currentFolderId: null,\n      dropdownSiteList: null,\n      breadcrumbTransform: this.transformNode.bind(this),\n      select,\n      showSearch: false,\n      showDropdownSiteList: false,\n      isSelectionValid: this.isSelectionValid.bind(this),\n      rowFilter: this.rowFilter.bind(this)\n    };\n\n    const query = {\n      query: {\n        query: `PATH:\"//${config.primaryPathName}\"`,\n        language: 'afts'\n      },\n      include: ['path', 'properties', 'allowableOperations', 'permissions']\n    };\n\n    from(this.searchApi.search(query))\n      .pipe(\n        switchMap((response) => {\n          const entry = response.list.entries[0].entry;\n          this.rootNode = entry;\n          data.currentFolderId = entry.id;\n\n          return this.dialog\n            .open(ContentNodeSelectorComponent, {\n              data,\n              panelClass: ['adf-content-node-selector-dialog', 'aca-template-node-selector-dialog'],\n              width: '630px'\n            })\n            .afterClosed();\n        }),\n        catchError((error) => {\n          this.notificationService.showError('APP.MESSAGES.ERRORS.GENERIC');\n          return of(error);\n        })\n      )\n      .subscribe({ next: () => select.complete() });\n\n    return select;\n  }\n\n  createTemplateDialog(node: Node): MatDialogRef<CreateFromTemplateDialogComponent> {\n    const dialog = this.dialog.open(CreateFromTemplateDialogComponent, {\n      data: node,\n      panelClass: 'aca-create-from-template-dialog',\n      width: '630px'\n    });\n    dialog.afterClosed().subscribe(() => this.focusCreateMenuButton());\n    return dialog;\n  }\n\n  private transformNode(node: Node): Node {\n    if (node?.path?.elements instanceof Array) {\n      node.path.elements = this.getPathElements(node);\n    }\n    return node;\n  }\n\n  private isSelectionValid(node: Node): boolean {\n    if (!node.path.elements.length) {\n      return false;\n    }\n\n    if (this.currentTemplateConfig.selectionType === 'folder') {\n      return node.isFolder;\n    }\n\n    return node.isFile;\n  }\n\n  private close() {\n    this.dialog.closeAll();\n    this.focusCreateMenuButton();\n  }\n\n  private title(selectionType: string) {\n    if (selectionType === 'file') {\n      return this.translation.instant('NODE_SELECTOR.SELECT_FILE_TEMPLATE_TITLE');\n    }\n\n    return this.translation.instant('NODE_SELECTOR.SELECT_FOLDER_TEMPLATE_TITLE');\n  }\n\n  private rowFilter(row: ShareDataRow): boolean {\n    const node: Node = row.node.entry;\n    return node.nodeType !== 'app:filelink' && node.nodeType !== 'app:folderlink';\n  }\n\n  private getPathElements(node: Node): PathElement[] {\n    return node.path.elements.filter((pathElement) => !this.rootNode.path.elements.some((rootPathElement) => pathElement.id === rootPathElement.id));\n  }\n\n  private focusCreateMenuButton(): void {\n    document.querySelector<HTMLElement>('app-toolbar-menu button[id=\"app.toolbar.create\"]').focus();\n  }\n}\n"]}

package/esm2022/lib/services/search-ai-navigation.service.mjs

@@ -0,0 +1,63 @@
+/*!
+ * Copyright © 2005-2024 Hyland Software, Inc. and its affiliates. All rights reserved.
+ *
+ * Alfresco Example Content Application
+ *
+ * This file is part of the Alfresco Example Content Application.
+ * If the software was purchased under a paid Alfresco license, the terms of
+ * the paid license agreement will prevail. Otherwise, the software is
+ * provided under the following open source license terms:
+ *
+ * The Alfresco Example Content Application is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * The Alfresco Example Content Application is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * from Hyland Software. If not, see <http://www.gnu.org/licenses/>.
+ */
+import { Injectable } from '@angular/core';
+import { Router } from '@angular/router';
+import { SearchAiService } from '@alfresco/adf-content-services';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/router";
+import * as i2 from "@alfresco/adf-content-services";
+class SearchAiNavigationService {
+    router;
+    searchAiService;
+    knowledgeRetrievalRoute = '/knowledge-retrieval';
+    previousRoute = '';
+    constructor(router, searchAiService) {
+        this.router = router;
+        this.searchAiService = searchAiService;
+    }
+    navigateToPreviousRouteOrCloseInput() {
+        if (this.router.url.includes(this.knowledgeRetrievalRoute)) {
+            void this.router.navigateByUrl(this.previousRoute || '/personal-files');
+        }
+        else {
+            this.searchAiService.updateSearchAiInputState({
+                active: false
+            });
+        }
+    }
+    navigateToSearchAi(queryParams) {
+        if (!this.router.url.includes(this.knowledgeRetrievalRoute)) {
+            this.previousRoute = this.router.url;
+        }
+        void this.router.navigate([this.knowledgeRetrievalRoute], { queryParams });
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.9", ngImport: i0, type: SearchAiNavigationService, deps: [{ token: i1.Router }, { token: i2.SearchAiService }], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.2.9", ngImport: i0, type: SearchAiNavigationService, providedIn: 'root' });
+}
+export { SearchAiNavigationService };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.9", ngImport: i0, type: SearchAiNavigationService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }], ctorParameters: function () { return [{ type: i1.Router }, { type: i2.SearchAiService }]; } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/store/app-store.module.mjs

@@ -0,0 +1,101 @@
+/*!
+ * Copyright © 2005-2024 Hyland Software, Inc. and its affiliates. All rights reserved.
+ *
+ * Alfresco Example Content Application
+ *
+ * This file is part of the Alfresco Example Content Application.
+ * If the software was purchased under a paid Alfresco license, the terms of
+ * the paid license agreement will prevail. Otherwise, the software is
+ * provided under the following open source license terms:
+ *
+ * The Alfresco Example Content Application is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * The Alfresco Example Content Application is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * from Hyland Software. If not, see <http://www.gnu.org/licenses/>.
+ */
+import { NgModule } from '@angular/core';
+import { StoreModule } from '@ngrx/store';
+import { appReducer } from './reducers/app.reducer';
+import { StoreRouterConnectingModule, FullRouterStateSerializer } from '@ngrx/router-store';
+import { EffectsModule } from '@ngrx/effects';
+import { RouterEffects, SnackbarEffects } from '@alfresco/aca-shared/store';
+import { AppEffects, NodeEffects, DownloadEffects, ViewerEffects, SearchEffects, LibraryEffects, UploadEffects, FavoriteEffects, TemplateEffects, ContextMenuEffects } from './effects';
+import { INITIAL_STATE } from './initial-state';
+import { SearchAiEffects } from './effects/search-ai.effects';
+import * as i0 from "@angular/core";
+import * as i1 from "@ngrx/store";
+import * as i2 from "@ngrx/router-store";
+import * as i3 from "@ngrx/effects";
+class AppStoreModule {
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.9", ngImport: i0, type: AppStoreModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+    static ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "16.2.9", ngImport: i0, type: AppStoreModule, imports: [i1.StoreRootModule, i2.StoreRouterConnectingModule, i3.EffectsRootModule] });
+    static ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "16.2.9", ngImport: i0, type: AppStoreModule, imports: [StoreModule.forRoot({ app: appReducer }, {
+                initialState: INITIAL_STATE,
+                runtimeChecks: {
+                    strictStateImmutability: false,
+                    strictActionImmutability: false
+                }
+            }),
+            StoreRouterConnectingModule.forRoot({
+                serializer: FullRouterStateSerializer,
+                stateKey: 'router'
+            }),
+            EffectsModule.forRoot([
+                AppEffects,
+                NodeEffects,
+                DownloadEffects,
+                ViewerEffects,
+                SearchEffects,
+                LibraryEffects,
+                UploadEffects,
+                FavoriteEffects,
+                TemplateEffects,
+                ContextMenuEffects,
+                SearchAiEffects,
+                SnackbarEffects,
+                RouterEffects
+            ])] });
+}
+export { AppStoreModule };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.9", ngImport: i0, type: AppStoreModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    imports: [
+                        StoreModule.forRoot({ app: appReducer }, {
+                            initialState: INITIAL_STATE,
+                            runtimeChecks: {
+                                strictStateImmutability: false,
+                                strictActionImmutability: false
+                            }
+                        }),
+                        StoreRouterConnectingModule.forRoot({
+                            serializer: FullRouterStateSerializer,
+                            stateKey: 'router'
+                        }),
+                        EffectsModule.forRoot([
+                            AppEffects,
+                            NodeEffects,
+                            DownloadEffects,
+                            ViewerEffects,
+                            SearchEffects,
+                            LibraryEffects,
+                            UploadEffects,
+                            FavoriteEffects,
+                            TemplateEffects,
+                            ContextMenuEffects,
+                            SearchAiEffects,
+                            SnackbarEffects,
+                            RouterEffects
+                        ])
+                    ]
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/store/effects/app.effects.mjs

@@ -0,0 +1,46 @@
+/*!
+ * Copyright © 2005-2024 Hyland Software, Inc. and its affiliates. All rights reserved.
+ *
+ * Alfresco Example Content Application
+ *
+ * This file is part of the Alfresco Example Content Application.
+ * If the software was purchased under a paid Alfresco license, the terms of
+ * the paid license agreement will prevail. Otherwise, the software is
+ * provided under the following open source license terms:
+ *
+ * The Alfresco Example Content Application is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * The Alfresco Example Content Application is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * from Hyland Software. If not, see <http://www.gnu.org/licenses/>.
+ */
+import { Actions, createEffect, ofType } from '@ngrx/effects';
+import { inject, Injectable } from '@angular/core';
+import { map } from 'rxjs/operators';
+import { AppActionTypes } from '@alfresco/aca-shared/store';
+import { DocumentListService } from '@alfresco/adf-content-services';
+import * as i0 from "@angular/core";
+class AppEffects {
+    actions$ = inject(Actions);
+    documentListService = inject(DocumentListService);
+    reload = createEffect(() => this.actions$.pipe(ofType(AppActionTypes.ReloadDocumentList), map(() => {
+        this.documentListService.reload();
+    })), { dispatch: false });
+    resetSelection = createEffect(() => this.actions$.pipe(ofType(AppActionTypes.ResetSelection), map(() => {
+        this.documentListService.resetSelection();
+    })), { dispatch: false });
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.9", ngImport: i0, type: AppEffects, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.2.9", ngImport: i0, type: AppEffects });
+}
+export { AppEffects };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.9", ngImport: i0, type: AppEffects, decorators: [{
+            type: Injectable
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/store/effects/contextmenu.effects.mjs

@@ -0,0 +1,65 @@
+/*!
+ * Copyright © 2005-2024 Hyland Software, Inc. and its affiliates. All rights reserved.
+ *
+ * Alfresco Example Content Application
+ *
+ * This file is part of the Alfresco Example Content Application.
+ * If the software was purchased under a paid Alfresco license, the terms of
+ * the paid license agreement will prevail. Otherwise, the software is
+ * provided under the following open source license terms:
+ *
+ * The Alfresco Example Content Application is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * The Alfresco Example Content Application is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * from Hyland Software. If not, see <http://www.gnu.org/licenses/>.
+ */
+import { ContextMenuActionTypes } from '@alfresco/aca-shared/store';
+import { inject, Injectable } from '@angular/core';
+import { Actions, createEffect, ofType } from '@ngrx/effects';
+import { map } from 'rxjs/operators';
+import { ContextMenuService } from '../../components/context-menu/context-menu.service';
+import * as i0 from "@angular/core";
+class ContextMenuEffects {
+    overlayRef = null;
+    contextMenuService = inject(ContextMenuService);
+    actions$ = inject(Actions);
+    contextMenu$ = createEffect(() => this.actions$.pipe(ofType(ContextMenuActionTypes.ContextMenu), map((action) => {
+        if (this.overlayRef) {
+            this.overlayRef.close();
+        }
+        this.overlayRef = this.contextMenuService.open({
+            source: action.event,
+            hasBackdrop: false,
+            backdropClass: 'cdk-overlay-transparent-backdrop',
+            panelClass: 'cdk-overlay-pane'
+        });
+    })), { dispatch: false });
+    customContextMenu$ = createEffect(() => this.actions$.pipe(ofType(ContextMenuActionTypes.CustomContextMenu), map((action) => {
+        if (action.payload?.length) {
+            if (this.overlayRef) {
+                this.overlayRef.close();
+            }
+            this.overlayRef = this.contextMenuService.open({
+                source: action.event,
+                hasBackdrop: false,
+                backdropClass: 'cdk-overlay-transparent-backdrop',
+                panelClass: 'cdk-overlay-pane'
+            }, action.payload);
+        }
+    })), { dispatch: false });
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.9", ngImport: i0, type: ContextMenuEffects, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.2.9", ngImport: i0, type: ContextMenuEffects });
+}
+export { ContextMenuEffects };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.9", ngImport: i0, type: ContextMenuEffects, decorators: [{
+            type: Injectable
+        }] });
+//# sourceMappingURL=data:application/json;base64,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