@alfresco/aca-shared 5.1.1 → 5.2.0

package/esm2022/store/actions/viewer.actions.mjs

@@ -0,0 +1,93 @@
+/*!
+ * 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/>.
+ */
+export var ViewerActionTypes;
+(function (ViewerActionTypes) {
+    ViewerActionTypes["ViewFile"] = "VIEW_FILE";
+    ViewerActionTypes["ViewNode"] = "VIEW_NODE";
+    ViewerActionTypes["ViewNodeVersion"] = "VIEW_NODE_VERSION";
+    ViewerActionTypes["FullScreen"] = "FULLSCREEN_VIEWER";
+    ViewerActionTypes["ClosePreview"] = "CLOSE_PREVIEW";
+    ViewerActionTypes["RefreshPreview"] = "REFRESH_PREVIEW";
+    ViewerActionTypes["PluginPreview"] = "PLUGIN_PREVIEW";
+})(ViewerActionTypes || (ViewerActionTypes = {}));
+export class ViewFileAction {
+    payload;
+    parentId;
+    type = ViewerActionTypes.ViewFile;
+    constructor(payload, parentId) {
+        this.payload = payload;
+        this.parentId = parentId;
+    }
+}
+export class ViewNodeAction {
+    nodeId;
+    viewNodeExtras;
+    type = ViewerActionTypes.ViewNode;
+    constructor(nodeId, viewNodeExtras) {
+        this.nodeId = nodeId;
+        this.viewNodeExtras = viewNodeExtras;
+    }
+}
+export class ViewNodeVersionAction {
+    nodeId;
+    versionId;
+    viewNodeExtras;
+    type = ViewerActionTypes.ViewNodeVersion;
+    constructor(nodeId, versionId, viewNodeExtras) {
+        this.nodeId = nodeId;
+        this.versionId = versionId;
+        this.viewNodeExtras = viewNodeExtras;
+    }
+}
+export class FullscreenViewerAction {
+    payload;
+    type = ViewerActionTypes.FullScreen;
+    constructor(payload) {
+        this.payload = payload;
+    }
+}
+export class ClosePreviewAction {
+    payload;
+    type = ViewerActionTypes.ClosePreview;
+    constructor(payload) {
+        this.payload = payload;
+    }
+}
+export class RefreshPreviewAction {
+    node;
+    type = ViewerActionTypes.RefreshPreview;
+    constructor(node) {
+        this.node = node;
+    }
+}
+export class PluginPreviewAction {
+    pluginRoute;
+    nodeId;
+    type = ViewerActionTypes.PluginPreview;
+    constructor(pluginRoute, nodeId) {
+        this.pluginRoute = pluginRoute;
+        this.nodeId = nodeId;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/store/effects/router.effects.mjs

@@ -0,0 +1,110 @@
+/*!
+ * 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 { Router } from '@angular/router';
+import { Actions, createEffect, ofType } from '@ngrx/effects';
+import { map } from 'rxjs/operators';
+import { Location } from '@angular/common';
+import { RouterActionTypes } from '../actions/router-action-types';
+import { NotificationService } from '@alfresco/adf-core';
+import * as i0 from "@angular/core";
+class RouterEffects {
+    notificationService = inject(NotificationService);
+    actions$ = inject(Actions);
+    router = inject(Router);
+    location = inject(Location);
+    navigateUrl$ = createEffect(() => this.actions$.pipe(ofType(RouterActionTypes.NavigateUrl), map((action) => {
+        if (action.payload) {
+            this.router.navigateByUrl(action.payload);
+        }
+    })), { dispatch: false });
+    navigateRoute$ = createEffect(() => this.actions$.pipe(ofType(RouterActionTypes.NavigateRoute), map((action) => {
+        this.router.navigate(action.payload);
+    })), { dispatch: false });
+    navigateToFolder$ = createEffect(() => this.actions$.pipe(ofType(RouterActionTypes.NavigateFolder), map((action) => {
+        if (action.payload?.entry) {
+            this.navigateToFolder(action.payload.entry);
+        }
+    })), { dispatch: false });
+    navigateToParentFolder$ = createEffect(() => this.actions$.pipe(ofType(RouterActionTypes.NavigateParentFolder), map((action) => {
+        if (action.payload?.entry) {
+            this.navigateToParentFolder(action.payload.entry);
+        }
+    })), { dispatch: false });
+    navigateToPreviousPage$ = createEffect(() => this.actions$.pipe(ofType(RouterActionTypes.NavigateToPreviousPage), map(() => this.location.back())), { dispatch: false });
+    navigateToFolder(node) {
+        let link = null;
+        const { path, id } = node;
+        if (path?.name && path?.elements) {
+            const isLibraryPath = this.isLibraryContent(path);
+            const parent = path.elements[path.elements.length - 1];
+            const area = isLibraryPath ? '/libraries' : '/personal-files';
+            if (!isLibraryPath) {
+                link = [area, id];
+            }
+            else {
+                // parent.id could be 'Site' folder or child as 'documentLibrary'
+                link = [area, parent.name === 'Sites' ? {} : id];
+            }
+            setTimeout(() => {
+                this.router.navigate(link);
+            }, 10);
+        }
+        else {
+            this.router.navigate(['/personal-files', node.id]);
+        }
+    }
+    navigateToParentFolder(node) {
+        let link = null;
+        const { path } = node;
+        if (path?.name && path?.elements) {
+            const isLibraryPath = this.isLibraryContent(path);
+            const parent = path.elements[path.elements.length - 1];
+            const area = isLibraryPath ? '/libraries' : '/personal-files';
+            if (!isLibraryPath) {
+                link = [area, parent.id];
+            }
+            else {
+                // parent.id could be 'Site' folder or child as 'documentLibrary'
+                link = [area, parent.name === 'Sites' ? {} : parent.id];
+            }
+            setTimeout(() => {
+                this.router.navigate(link);
+            }, 10);
+        }
+        else {
+            this.notificationService.showError('APP.MESSAGES.ERRORS.CANNOT_NAVIGATE_LOCATION');
+        }
+    }
+    isLibraryContent(path) {
+        return path && path.elements.length >= 2 && path.elements[1].name === 'Sites';
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.9", ngImport: i0, type: RouterEffects, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.2.9", ngImport: i0, type: RouterEffects });
+}
+export { RouterEffects };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.9", ngImport: i0, type: RouterEffects, decorators: [{
+            type: Injectable
+        }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"router.effects.js","sourceRoot":"","sources":["../../../../../../projects/aca-shared/store/src/effects/router.effects.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AAEH,OAAO,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AACnD,OAAO,EAAE,MAAM,EAAE,MAAM,iBAAiB,CAAC;AACzC,OAAO,EAAE,OAAO,EAAE,YAAY,EAAE,MAAM,EAAE,MAAM,eAAe,CAAC;AAE9D,OAAO,EAAE,GAAG,EAAE,MAAM,gBAAgB,CAAC;AACrC,OAAO,EAAE,QAAQ,EAAE,MAAM,iBAAiB,CAAC;AAE3C,OAAO,EAAE,iBAAiB,EAAE,MAAM,gCAAgC,CAAC;AACnE,OAAO,EAAE,mBAAmB,EAAE,MAAM,oBAAoB,CAAC;;AAEzD,MACa,aAAa;IAChB,mBAAmB,GAAG,MAAM,CAAC,mBAAmB,CAAC,CAAC;IAClD,QAAQ,GAAG,MAAM,CAAC,OAAO,CAAC,CAAC;IAC3B,MAAM,GAAG,MAAM,CAAC,MAAM,CAAC,CAAC;IACxB,QAAQ,GAAG,MAAM,CAAC,QAAQ,CAAC,CAAC;IAEpC,YAAY,GAAG,YAAY,CACzB,GAAG,EAAE,CACH,IAAI,CAAC,QAAQ,CAAC,IAAI,CAChB,MAAM,CAAoB,iBAAiB,CAAC,WAAW,CAAC,EACxD,GAAG,CAAC,CAAC,MAAM,EAAE,EAAE;QACb,IAAI,MAAM,CAAC,OAAO,EAAE;YAClB,IAAI,CAAC,MAAM,CAAC,aAAa,CAAC,MAAM,CAAC,OAAO,CAAC,CAAC;SAC3C;IACH,CAAC,CAAC,CACH,EACH,EAAE,QAAQ,EAAE,KAAK,EAAE,CACpB,CAAC;IAEF,cAAc,GAAG,YAAY,CAC3B,GAAG,EAAE,CACH,IAAI,CAAC,QAAQ,CAAC,IAAI,CAChB,MAAM,CAAsB,iBAAiB,CAAC,aAAa,CAAC,EAC5D,GAAG,CAAC,CAAC,MAAM,EAAE,EAAE;QACb,IAAI,CAAC,MAAM,CAAC,QAAQ,CAAC,MAAM,CAAC,OAAO,CAAC,CAAC;IACvC,CAAC,CAAC,CACH,EACH,EAAE,QAAQ,EAAE,KAAK,EAAE,CACpB,CAAC;IAEF,iBAAiB,GAAG,YAAY,CAC9B,GAAG,EAAE,CACH,IAAI,CAAC,QAAQ,CAAC,IAAI,CAChB,MAAM,CAAmB,iBAAiB,CAAC,cAAc,CAAC,EAC1D,GAAG,CAAC,CAAC,MAAM,EAAE,EAAE;QACb,IAAI,MAAM,CAAC,OAAO,EAAE,KAAK,EAAE;YACzB,IAAI,CAAC,gBAAgB,CAAC,MAAM,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC;SAC7C;IACH,CAAC,CAAC,CACH,EACH,EAAE,QAAQ,EAAE,KAAK,EAAE,CACpB,CAAC;IAEF,uBAAuB,GAAG,YAAY,CACpC,GAAG,EAAE,CACH,IAAI,CAAC,QAAQ,CAAC,IAAI,CAChB,MAAM,CAAyB,iBAAiB,CAAC,oBAAoB,CAAC,EACtE,GAAG,CAAC,CAAC,MAAM,EAAE,EAAE;QACb,IAAI,MAAM,CAAC,OAAO,EAAE,KAAK,EAAE;YACzB,IAAI,CAAC,sBAAsB,CAAC,MAAM,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC;SACnD;IACH,CAAC,CAAC,CACH,EACH,EAAE,QAAQ,EAAE,KAAK,EAAE,CACpB,CAAC;IAEF,uBAAuB,GAAG,YAAY,CACpC,GAAG,EAAE,CACH,IAAI,CAAC,QAAQ,CAAC,IAAI,CAChB,MAAM,CAAyB,iBAAiB,CAAC,sBAAsB,CAAC,EACxE,GAAG,CAAC,GAAG,EAAE,CAAC,IAAI,CAAC,QAAQ,CAAC,IAAI,EAAE,CAAC,CAChC,EACH,EAAE,QAAQ,EAAE,KAAK,EAAE,CACpB,CAAC;IAEM,gBAAgB,CAAC,IAAU;QACjC,IAAI,IAAI,GAAU,IAAI,CAAC;QACvB,MAAM,EAAE,IAAI,EAAE,EAAE,EAAE,GAAG,IAAI,CAAC;QAE1B,IAAI,IAAI,EAAE,IAAI,IAAI,IAAI,EAAE,QAAQ,EAAE;YAChC,MAAM,aAAa,GAAG,IAAI,CAAC,gBAAgB,CAAC,IAAI,CAAC,CAAC;YAElD,MAAM,MAAM,GAAG,IAAI,CAAC,QAAQ,CAAC,IAAI,CAAC,QAAQ,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC;YACvD,MAAM,IAAI,GAAG,aAAa,CAAC,CAAC,CAAC,YAAY,CAAC,CAAC,CAAC,iBAAiB,CAAC;YAE9D,IAAI,CAAC,aAAa,EAAE;gBAClB,IAAI,GAAG,CAAC,IAAI,EAAE,EAAE,CAAC,CAAC;aACnB;iBAAM;gBACL,iEAAiE;gBACjE,IAAI,GAAG,CAAC,IAAI,EAAE,MAAM,CAAC,IAAI,KAAK,OAAO,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC;aAClD;YAED,UAAU,CAAC,GAAG,EAAE;gBACd,IAAI,CAAC,MAAM,CAAC,QAAQ,CAAC,IAAI,CAAC,CAAC;YAC7B,CAAC,EAAE,EAAE,CAAC,CAAC;SACR;aAAM;YACL,IAAI,CAAC,MAAM,CAAC,QAAQ,CAAC,CAAC,iBAAiB,EAAE,IAAI,CAAC,EAAE,CAAC,CAAC,CAAC;SACpD;IACH,CAAC;IAEO,sBAAsB,CAAC,IAAU;QACvC,IAAI,IAAI,GAAU,IAAI,CAAC;QACvB,MAAM,EAAE,IAAI,EAAE,GAAG,IAAI,CAAC;QAEtB,IAAI,IAAI,EAAE,IAAI,IAAI,IAAI,EAAE,QAAQ,EAAE;YAChC,MAAM,aAAa,GAAG,IAAI,CAAC,gBAAgB,CAAC,IAAI,CAAC,CAAC;YAElD,MAAM,MAAM,GAAG,IAAI,CAAC,QAAQ,CAAC,IAAI,CAAC,QAAQ,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC;YACvD,MAAM,IAAI,GAAG,aAAa,CAAC,CAAC,CAAC,YAAY,CAAC,CAAC,CAAC,iBAAiB,CAAC;YAE9D,IAAI,CAAC,aAAa,EAAE;gBAClB,IAAI,GAAG,CAAC,IAAI,EAAE,MAAM,CAAC,EAAE,CAAC,CAAC;aAC1B;iBAAM;gBACL,iEAAiE;gBACjE,IAAI,GAAG,CAAC,IAAI,EAAE,MAAM,CAAC,IAAI,KAAK,OAAO,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,MAAM,CAAC,EAAE,CAAC,CAAC;aACzD;YAED,UAAU,CAAC,GAAG,EAAE;gBACd,IAAI,CAAC,MAAM,CAAC,QAAQ,CAAC,IAAI,CAAC,CAAC;YAC7B,CAAC,EAAE,EAAE,CAAC,CAAC;SACR;aAAM;YACL,IAAI,CAAC,mBAAmB,CAAC,SAAS,CAAC,8CAA8C,CAAC,CAAC;SACpF;IACH,CAAC;IAEO,gBAAgB,CAAC,IAAc;QACrC,OAAO,IAAI,IAAI,IAAI,CAAC,QAAQ,CAAC,MAAM,IAAI,CAAC,IAAI,IAAI,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC,IAAI,KAAK,OAAO,CAAC;IAChF,CAAC;uGArHU,aAAa;2GAAb,aAAa;;SAAb,aAAa;2FAAb,aAAa;kBADzB,UAAU","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 { Router } from '@angular/router';\nimport { Actions, createEffect, ofType } from '@ngrx/effects';\nimport { Node, PathInfo } from '@alfresco/js-api';\nimport { map } from 'rxjs/operators';\nimport { Location } from '@angular/common';\nimport { NavigateRouteAction, NavigateToFolder, NavigateToParentFolder, NavigateToPreviousPage, NavigateUrlAction } from '../actions/router.actions';\nimport { RouterActionTypes } from '../actions/router-action-types';\nimport { NotificationService } from '@alfresco/adf-core';\n\n@Injectable()\nexport class RouterEffects {\n  private notificationService = inject(NotificationService);\n  private actions$ = inject(Actions);\n  private router = inject(Router);\n  private location = inject(Location);\n\n  navigateUrl$ = createEffect(\n    () =>\n      this.actions$.pipe(\n        ofType<NavigateUrlAction>(RouterActionTypes.NavigateUrl),\n        map((action) => {\n          if (action.payload) {\n            this.router.navigateByUrl(action.payload);\n          }\n        })\n      ),\n    { dispatch: false }\n  );\n\n  navigateRoute$ = createEffect(\n    () =>\n      this.actions$.pipe(\n        ofType<NavigateRouteAction>(RouterActionTypes.NavigateRoute),\n        map((action) => {\n          this.router.navigate(action.payload);\n        })\n      ),\n    { dispatch: false }\n  );\n\n  navigateToFolder$ = createEffect(\n    () =>\n      this.actions$.pipe(\n        ofType<NavigateToFolder>(RouterActionTypes.NavigateFolder),\n        map((action) => {\n          if (action.payload?.entry) {\n            this.navigateToFolder(action.payload.entry);\n          }\n        })\n      ),\n    { dispatch: false }\n  );\n\n  navigateToParentFolder$ = createEffect(\n    () =>\n      this.actions$.pipe(\n        ofType<NavigateToParentFolder>(RouterActionTypes.NavigateParentFolder),\n        map((action) => {\n          if (action.payload?.entry) {\n            this.navigateToParentFolder(action.payload.entry);\n          }\n        })\n      ),\n    { dispatch: false }\n  );\n\n  navigateToPreviousPage$ = createEffect(\n    () =>\n      this.actions$.pipe(\n        ofType<NavigateToPreviousPage>(RouterActionTypes.NavigateToPreviousPage),\n        map(() => this.location.back())\n      ),\n    { dispatch: false }\n  );\n\n  private navigateToFolder(node: Node) {\n    let link: any[] = null;\n    const { path, id } = node;\n\n    if (path?.name && path?.elements) {\n      const isLibraryPath = this.isLibraryContent(path);\n\n      const parent = path.elements[path.elements.length - 1];\n      const area = isLibraryPath ? '/libraries' : '/personal-files';\n\n      if (!isLibraryPath) {\n        link = [area, id];\n      } else {\n        // parent.id could be 'Site' folder or child as 'documentLibrary'\n        link = [area, parent.name === 'Sites' ? {} : id];\n      }\n\n      setTimeout(() => {\n        this.router.navigate(link);\n      }, 10);\n    } else {\n      this.router.navigate(['/personal-files', node.id]);\n    }\n  }\n\n  private navigateToParentFolder(node: Node) {\n    let link: any[] = null;\n    const { path } = node;\n\n    if (path?.name && path?.elements) {\n      const isLibraryPath = this.isLibraryContent(path);\n\n      const parent = path.elements[path.elements.length - 1];\n      const area = isLibraryPath ? '/libraries' : '/personal-files';\n\n      if (!isLibraryPath) {\n        link = [area, parent.id];\n      } else {\n        // parent.id could be 'Site' folder or child as 'documentLibrary'\n        link = [area, parent.name === 'Sites' ? {} : parent.id];\n      }\n\n      setTimeout(() => {\n        this.router.navigate(link);\n      }, 10);\n    } else {\n      this.notificationService.showError('APP.MESSAGES.ERRORS.CANNOT_NAVIGATE_LOCATION');\n    }\n  }\n\n  private isLibraryContent(path: PathInfo): boolean {\n    return path && path.elements.length >= 2 && path.elements[1].name === 'Sites';\n  }\n}\n"]}

package/esm2022/store/effects/snackbar.effects.mjs

@@ -0,0 +1,80 @@
+/*!
+ * 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 { SnackbarContentComponent, TranslationService } from '@alfresco/adf-core';
+import { inject, Injectable } from '@angular/core';
+import { MatSnackBar } from '@angular/material/snack-bar';
+import { Actions, createEffect, ofType } from '@ngrx/effects';
+import { Store } from '@ngrx/store';
+import { map } from 'rxjs/operators';
+import { SnackbarActionTypes } from '../actions/snackbar.actions';
+import * as i0 from "@angular/core";
+class SnackbarEffects {
+    store = inject((Store));
+    actions$ = inject(Actions);
+    snackBar = inject(MatSnackBar);
+    translationService = inject(TranslationService);
+    infoEffect = createEffect(() => this.actions$.pipe(ofType(SnackbarActionTypes.Info), map((action) => {
+        this.showSnackBar(action, 'adf-info-snackbar');
+    })), { dispatch: false });
+    warningEffect = createEffect(() => this.actions$.pipe(ofType(SnackbarActionTypes.Warning), map((action) => {
+        this.showSnackBar(action, 'adf-warning-snackbar');
+    })), { dispatch: false });
+    errorEffect = createEffect(() => this.actions$.pipe(ofType(SnackbarActionTypes.Error), map((action) => {
+        this.showSnackBar(action, 'adf-error-snackbar');
+    })), { dispatch: false });
+    showSnackBar(action, panelClass) {
+        const message = this.translate(action.payload, action.params);
+        let actionName = null;
+        if (action.userAction) {
+            actionName = this.translate(action.userAction.title);
+        }
+        const snackBarRef = this.snackBar.openFromComponent(SnackbarContentComponent, {
+            ...(action.duration !== undefined && action.duration !== null && { duration: action.duration }),
+            panelClass,
+            data: {
+                message,
+                actionLabel: actionName,
+                actionIcon: 'close',
+                actionIconAriaLabel: 'CLOSE',
+                showAction: true,
+                callActionOnIconClick: false
+            }
+        });
+        if (action.userAction) {
+            snackBarRef.onAction().subscribe(() => {
+                this.store.dispatch(action.userAction.action);
+            });
+        }
+    }
+    translate(message, params) {
+        return this.translationService.instant(message, params);
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.9", ngImport: i0, type: SnackbarEffects, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.2.9", ngImport: i0, type: SnackbarEffects });
+}
+export { SnackbarEffects };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.9", ngImport: i0, type: SnackbarEffects, decorators: [{
+            type: Injectable
+        }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"snackbar.effects.js","sourceRoot":"","sources":["../../../../../../projects/aca-shared/store/src/effects/snackbar.effects.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 { SnackbarContentComponent, SnackBarData, TranslationService } from '@alfresco/adf-core';\nimport { inject, Injectable } from '@angular/core';\nimport { MatSnackBar } from '@angular/material/snack-bar';\nimport { Actions, createEffect, ofType } from '@ngrx/effects';\nimport { Store } from '@ngrx/store';\nimport { map } from 'rxjs/operators';\nimport { AppStore } from '../states/app.state';\nimport { SnackbarAction, SnackbarActionTypes, SnackbarErrorAction, SnackbarInfoAction, SnackbarWarningAction } from '../actions/snackbar.actions';\n\n@Injectable()\nexport class SnackbarEffects {\n  private store = inject(Store<AppStore>);\n  private actions$ = inject(Actions);\n  private snackBar = inject(MatSnackBar);\n  private translationService = inject(TranslationService);\n\n  infoEffect = createEffect(\n    () =>\n      this.actions$.pipe(\n        ofType<SnackbarInfoAction>(SnackbarActionTypes.Info),\n        map((action: SnackbarInfoAction) => {\n          this.showSnackBar(action, 'adf-info-snackbar');\n        })\n      ),\n    { dispatch: false }\n  );\n\n  warningEffect = createEffect(\n    () =>\n      this.actions$.pipe(\n        ofType<SnackbarWarningAction>(SnackbarActionTypes.Warning),\n        map((action: SnackbarWarningAction) => {\n          this.showSnackBar(action, 'adf-warning-snackbar');\n        })\n      ),\n    { dispatch: false }\n  );\n\n  errorEffect = createEffect(\n    () =>\n      this.actions$.pipe(\n        ofType<SnackbarErrorAction>(SnackbarActionTypes.Error),\n        map((action: SnackbarErrorAction) => {\n          this.showSnackBar(action, 'adf-error-snackbar');\n        })\n      ),\n    { dispatch: false }\n  );\n\n  private showSnackBar(action: SnackbarAction, panelClass: string) {\n    const message = this.translate(action.payload, action.params);\n\n    let actionName: string = null;\n    if (action.userAction) {\n      actionName = this.translate(action.userAction.title);\n    }\n    const snackBarRef = this.snackBar.openFromComponent<SnackbarContentComponent, SnackBarData>(SnackbarContentComponent, {\n      ...(action.duration !== undefined && action.duration !== null && { duration: action.duration }),\n      panelClass,\n      data: {\n        message,\n        actionLabel: actionName,\n        actionIcon: 'close',\n        actionIconAriaLabel: 'CLOSE',\n        showAction: true,\n        callActionOnIconClick: false\n      }\n    });\n\n    if (action.userAction) {\n      snackBarRef.onAction().subscribe(() => {\n        this.store.dispatch(action.userAction.action);\n      });\n    }\n  }\n\n  private translate(message: string, params?: any): string {\n    return this.translationService.instant(message, params);\n  }\n}\n"]}