@alfresco/aca-shared 5.1.1 → 5.2.0

package/esm2022/lib/services/user-profile.service.mjs

@@ -0,0 +1,76 @@
+/*!
+ * 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 { AlfrescoApiService, GroupService } from '@alfresco/adf-content-services';
+import { BehaviorSubject } from 'rxjs';
+import { PeopleApi } from '@alfresco/js-api';
+import * as i0 from "@angular/core";
+class UserProfileService {
+    api = inject(AlfrescoApiService);
+    groupService = inject(GroupService);
+    get peopleApi() {
+        return new PeopleApi(this.api.getInstance());
+    }
+    userProfile = new BehaviorSubject(null);
+    userProfile$ = this.userProfile.asObservable();
+    /**
+     * Load user profile.
+     */
+    async loadUserProfile() {
+        const groupsEntries = await this.groupService.listAllGroupMembershipsForPerson('-me-', { maxItems: 250 });
+        const groups = [];
+        if (groupsEntries) {
+            groups.push(...groupsEntries.map((obj) => obj.entry));
+        }
+        const { entry: user } = await this.peopleApi.getPerson('-me-');
+        const id = user.id;
+        const firstName = user.firstName || '';
+        const lastName = user.lastName || '';
+        const userName = `${firstName} ${lastName}`;
+        const initials = [firstName[0], lastName[0]].join('');
+        const email = user.email;
+        const capabilities = user.capabilities;
+        const isAdmin = capabilities ? capabilities.isAdmin : true;
+        const profile = {
+            firstName,
+            lastName,
+            userName,
+            initials,
+            isAdmin,
+            id,
+            groups,
+            email
+        };
+        this.userProfile.next(profile);
+        return profile;
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.9", ngImport: i0, type: UserProfileService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.2.9", ngImport: i0, type: UserProfileService, providedIn: 'root' });
+}
+export { UserProfileService };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.9", ngImport: i0, type: UserProfileService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/testing/lib-testing-module.mjs

@@ -0,0 +1,163 @@
+/*!
+ * 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, NgModule } from '@angular/core';
+import { TranslateLoader, TranslateModule } from '@ngx-translate/core';
+import { NoopAnimationsModule } from '@angular/platform-browser/animations';
+import { TranslateLoaderService, TranslationMock, TranslationService } from '@alfresco/adf-core';
+import { AlfrescoApiService, AlfrescoApiServiceMock } from '@alfresco/adf-content-services';
+import { HttpClientModule } from '@angular/common/http';
+import { RouterTestingModule } from '@angular/router/testing';
+import { EffectsModule } from '@ngrx/effects';
+import { StoreModule } from '@ngrx/store';
+import { CommonModule } from '@angular/common';
+import { MatIconTestingModule } from '@angular/material/icon/testing';
+import { OverlayModule } from '@angular/cdk/overlay';
+import { RepositoryInfo } from '@alfresco/js-api';
+import { BehaviorSubject, of } from 'rxjs';
+import { DocumentBasePageService } from '../../public-api';
+import * as i0 from "@angular/core";
+import * as i1 from "@ngrx/store";
+import * as i2 from "@ngrx/effects";
+import * as i3 from "@ngx-translate/core";
+export const initialState = {
+    app: {
+        appName: 'Alfresco Content Application',
+        logoPath: 'assets/images/alfresco-logo-white.svg',
+        sharedUrl: '',
+        user: {
+            isAdmin: null,
+            id: null,
+            firstName: '',
+            lastName: ''
+        },
+        selection: {
+            nodes: [],
+            libraries: [],
+            isEmpty: true,
+            count: 0
+        },
+        navigation: {
+            currentFolder: null
+        },
+        infoDrawerOpened: false,
+        infoDrawerMetadataAspect: '',
+        showFacetFilter: true,
+        repository: {
+            status: {
+                isQuickShareEnabled: true
+            }
+        }
+    }
+};
+export const discoveryApiServiceMockValue = {
+    ecmProductInfo$: new BehaviorSubject(null),
+    getEcmProductInfo: () => of(new RepositoryInfo({
+        version: {
+            major: '10.0.0'
+        }
+    }))
+};
+class DocumentBasePageServiceMock extends DocumentBasePageService {
+    canUpdateNode() {
+        return true;
+    }
+    canUploadContent() {
+        return true;
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.9", ngImport: i0, type: DocumentBasePageServiceMock, deps: null, target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.2.9", ngImport: i0, type: DocumentBasePageServiceMock });
+}
+export { DocumentBasePageServiceMock };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.9", ngImport: i0, type: DocumentBasePageServiceMock, decorators: [{
+            type: Injectable
+        }] });
+class LibTestingModule {
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.9", ngImport: i0, type: LibTestingModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+    static ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "16.2.9", ngImport: i0, type: LibTestingModule, imports: [NoopAnimationsModule,
+            CommonModule,
+            HttpClientModule,
+            RouterTestingModule,
+            MatIconTestingModule,
+            StoreModule,
+            OverlayModule, i1.StoreRootModule, i2.EffectsRootModule, i3.TranslateModule], exports: [TranslateModule] });
+    static ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "16.2.9", ngImport: i0, type: LibTestingModule, providers: [
+            { provide: AlfrescoApiService, useClass: AlfrescoApiServiceMock },
+            { provide: TranslationService, useClass: TranslationMock }
+        ], imports: [NoopAnimationsModule,
+            CommonModule,
+            HttpClientModule,
+            RouterTestingModule,
+            MatIconTestingModule,
+            StoreModule,
+            OverlayModule,
+            StoreModule.forRoot({ app: null }, {
+                initialState,
+                runtimeChecks: {
+                    strictStateImmutability: false,
+                    strictActionImmutability: false
+                }
+            }),
+            EffectsModule.forRoot([]),
+            TranslateModule.forRoot({
+                loader: {
+                    provide: TranslateLoader,
+                    useClass: TranslateLoaderService
+                }
+            }), TranslateModule] });
+}
+export { LibTestingModule };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.9", ngImport: i0, type: LibTestingModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    imports: [
+                        NoopAnimationsModule,
+                        CommonModule,
+                        HttpClientModule,
+                        RouterTestingModule,
+                        MatIconTestingModule,
+                        StoreModule,
+                        OverlayModule,
+                        StoreModule.forRoot({ app: null }, {
+                            initialState,
+                            runtimeChecks: {
+                                strictStateImmutability: false,
+                                strictActionImmutability: false
+                            }
+                        }),
+                        EffectsModule.forRoot([]),
+                        TranslateModule.forRoot({
+                            loader: {
+                                provide: TranslateLoader,
+                                useClass: TranslateLoaderService
+                            }
+                        })
+                    ],
+                    exports: [TranslateModule],
+                    providers: [
+                        { provide: AlfrescoApiService, useClass: AlfrescoApiServiceMock },
+                        { provide: TranslationService, useClass: TranslationMock }
+                    ]
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"lib-testing-module.js","sourceRoot":"","sources":["../../../../../../projects/aca-shared/src/lib/testing/lib-testing-module.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 { Injectable, NgModule } from '@angular/core';\nimport { TranslateLoader, TranslateModule } from '@ngx-translate/core';\nimport { NoopAnimationsModule } from '@angular/platform-browser/animations';\nimport { TranslateLoaderService, TranslationMock, TranslationService } from '@alfresco/adf-core';\nimport { AlfrescoApiService, AlfrescoApiServiceMock } from '@alfresco/adf-content-services';\nimport { HttpClientModule } from '@angular/common/http';\nimport { RouterTestingModule } from '@angular/router/testing';\nimport { EffectsModule } from '@ngrx/effects';\nimport { StoreModule } from '@ngrx/store';\nimport { CommonModule } from '@angular/common';\nimport { MatIconTestingModule } from '@angular/material/icon/testing';\nimport { OverlayModule } from '@angular/cdk/overlay';\nimport { RepositoryInfo, VersionInfo } from '@alfresco/js-api';\nimport { BehaviorSubject, Observable, of } from 'rxjs';\nimport { DocumentBasePageService } from '../../public-api';\n\nexport const initialState = {\n  app: {\n    appName: 'Alfresco Content Application',\n    logoPath: 'assets/images/alfresco-logo-white.svg',\n    sharedUrl: '',\n    user: {\n      isAdmin: null,\n      id: null,\n      firstName: '',\n      lastName: ''\n    },\n    selection: {\n      nodes: [],\n      libraries: [],\n      isEmpty: true,\n      count: 0\n    },\n    navigation: {\n      currentFolder: null\n    },\n    infoDrawerOpened: false,\n    infoDrawerMetadataAspect: '',\n    showFacetFilter: true,\n    repository: {\n      status: {\n        isQuickShareEnabled: true\n      }\n    } as any\n  }\n};\n\nexport const discoveryApiServiceMockValue = {\n  ecmProductInfo$: new BehaviorSubject<RepositoryInfo | null>(null),\n  getEcmProductInfo: (): Observable<RepositoryInfo> =>\n    of(\n      new RepositoryInfo({\n        version: {\n          major: '10.0.0'\n        } as VersionInfo\n      })\n    )\n};\n\n@Injectable()\nexport class DocumentBasePageServiceMock extends DocumentBasePageService {\n  canUpdateNode(): boolean {\n    return true;\n  }\n\n  canUploadContent(): boolean {\n    return true;\n  }\n}\n\n@NgModule({\n  imports: [\n    NoopAnimationsModule,\n    CommonModule,\n    HttpClientModule,\n    RouterTestingModule,\n    MatIconTestingModule,\n    StoreModule,\n    OverlayModule,\n    StoreModule.forRoot(\n      { app: null },\n      {\n        initialState,\n        runtimeChecks: {\n          strictStateImmutability: false,\n          strictActionImmutability: false\n        }\n      }\n    ),\n    EffectsModule.forRoot([]),\n    TranslateModule.forRoot({\n      loader: {\n        provide: TranslateLoader,\n        useClass: TranslateLoaderService\n      }\n    })\n  ],\n  exports: [TranslateModule],\n  providers: [\n    { provide: AlfrescoApiService, useClass: AlfrescoApiServiceMock },\n    { provide: TranslationService, useClass: TranslationMock }\n  ]\n})\nexport class LibTestingModule {}\n"]}

package/esm2022/public-api.mjs

@@ -0,0 +1,62 @@
+/*!
+ * 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 * from './lib/adf-extensions/extensions-data-loader.guard';
+export * from './lib/components/page-layout/page-layout-content.component';
+export * from './lib/components/page-layout/page-layout-error.component';
+export * from './lib/components/page-layout/page-layout-header.component';
+export * from './lib/components/page-layout/page-layout.component';
+export * from './lib/components/page-layout/page-layout.module';
+export * from './lib/components/locked-by/locked-by.component';
+export * from './lib/components/generic-error/generic-error.component';
+export * from './lib/components/toolbar/toolbar.component';
+export * from './lib/components/toolbar/toolbar-action/toolbar-action.component';
+export * from './lib/components/toolbar/toolbar-button/toolbar-button.component';
+export * from './lib/components/toolbar/toolbar-menu/toolbar-menu.component';
+export * from './lib/components/toolbar/toolbar-menu-item/toolbar-menu-item.component';
+export * from './lib/components/info-drawer/info-drawer.component';
+export * from './lib/components/document-base-page/document-base-page.component';
+export * from './lib/components/document-base-page/document-base-page.service';
+export * from './lib/components/open-in-app/open-in-app.component';
+export * from './lib/constants';
+export * from './lib/directives/contextmenu/contextmenu.directive';
+export * from './lib/directives/pagination.directive';
+export * from './lib/models/types';
+export * from './lib/models/viewer.rules';
+export * from './lib/routing/shared.guard';
+export * from './lib/routing/plugin-enabled.guard';
+export * from './lib/services/app.service';
+export * from './lib/services/content-api.service';
+export * from './lib/services/node-permission.service';
+export * from './lib/services/app.extension.service';
+export * from './lib/services/router.extension.service';
+export * from './lib/services/app-hook.service';
+export * from './lib/services/auto-download.service';
+export * from './lib/services/app-settings.service';
+export * from './lib/services/user-profile.service';
+export * from './lib/services/navigation-history.service';
+export * from './lib/utils/node.utils';
+export * from './lib/testing/lib-testing-module';
+export * from './lib/deprecated/shared.module';
+export * from './lib/deprecated/shared-toolbar.module';
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/store/actions/app.actions.mjs

@@ -0,0 +1,116 @@
+/*!
+ * 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 { AppActionTypes } from './app-action-types';
+export class SetCurrentFolderAction {
+    payload;
+    type = AppActionTypes.SetCurrentFolder;
+    constructor(payload) {
+        this.payload = payload;
+    }
+}
+export class SetCurrentNodeVersionAction {
+    payload;
+    type = AppActionTypes.SetCurrentVersion;
+    constructor(payload) {
+        this.payload = payload;
+    }
+}
+export class SetCurrentUrlAction {
+    payload;
+    type = AppActionTypes.SetCurrentUrl;
+    constructor(payload) {
+        this.payload = payload;
+    }
+}
+export class SetUserProfileAction {
+    payload;
+    type = AppActionTypes.SetUserProfile;
+    constructor(payload) {
+        this.payload = payload;
+    }
+}
+export class ToggleInfoDrawerAction {
+    type = AppActionTypes.ToggleInfoDrawer;
+}
+/** @deprecated use @alfresco/adf-content-services/DocumentListService.reload() instead */
+export class ReloadDocumentListAction {
+    payload;
+    type = AppActionTypes.ReloadDocumentList;
+    constructor(payload) {
+        this.payload = payload;
+    }
+}
+export class ResetSelectionAction {
+    payload;
+    type = AppActionTypes.ResetSelection;
+    constructor(payload) {
+        this.payload = payload;
+    }
+}
+export class SetInfoDrawerStateAction {
+    payload;
+    type = AppActionTypes.SetInfoDrawerState;
+    constructor(payload) {
+        this.payload = payload;
+    }
+}
+export class SetRepositoryInfoAction {
+    payload;
+    type = AppActionTypes.SetRepositoryInfo;
+    constructor(payload) {
+        this.payload = payload;
+    }
+}
+export class SetFileUploadingDialogAction {
+    payload;
+    type = AppActionTypes.SetFileUploadingDialog;
+    constructor(payload) {
+        this.payload = payload;
+    }
+}
+export class ShowInfoDrawerPreviewAction {
+    type = AppActionTypes.ShowInfoDrawerPreview;
+}
+export class SetInfoDrawerPreviewStateAction {
+    payload;
+    type = AppActionTypes.SetInfoDrawerPreviewState;
+    constructor(payload) {
+        this.payload = payload;
+    }
+}
+export class ShowLoaderAction {
+    payload;
+    type = AppActionTypes.ShowLoaderAction;
+    constructor(payload) {
+        this.payload = payload;
+    }
+}
+export class SetSearchItemsTotalCountAction {
+    payload;
+    type = AppActionTypes.SetSearchItemsTotalCount;
+    constructor(payload) {
+        this.payload = payload;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/store/actions/context-menu-action-types.mjs

@@ -0,0 +1,29 @@
+/*!
+ * 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 ContextMenuActionTypes;
+(function (ContextMenuActionTypes) {
+    ContextMenuActionTypes["ContextMenu"] = "CONTEXT_MENU";
+    ContextMenuActionTypes["CustomContextMenu"] = "CUSTOM_CONTEXT_MENU";
+})(ContextMenuActionTypes || (ContextMenuActionTypes = {}));
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/store/actions/contextmenu.actions.mjs

@@ -0,0 +1,41 @@
+/*!
+ * 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 './context-menu-action-types';
+export class ContextMenu {
+    event;
+    type = ContextMenuActionTypes.ContextMenu;
+    constructor(event) {
+        this.event = event;
+    }
+}
+export class CustomContextMenu {
+    event;
+    payload;
+    type = ContextMenuActionTypes.CustomContextMenu;
+    constructor(event, payload = []) {
+        this.event = event;
+        this.payload = payload;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/store/actions/library.actions.mjs

@@ -0,0 +1,67 @@
+/*!
+ * 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 LibraryActionTypes;
+(function (LibraryActionTypes) {
+    LibraryActionTypes["Delete"] = "DELETE_LIBRARY";
+    LibraryActionTypes["Create"] = "CREATE_LIBRARY";
+    LibraryActionTypes["Navigate"] = "NAVIGATE_LIBRARY";
+    LibraryActionTypes["Update"] = "UPDATE_LIBRARY";
+    LibraryActionTypes["Leave"] = "LEAVE_LIBRARY";
+})(LibraryActionTypes || (LibraryActionTypes = {}));
+export class DeleteLibraryAction {
+    payload;
+    type = LibraryActionTypes.Delete;
+    constructor(payload) {
+        this.payload = payload;
+    }
+}
+export class CreateLibraryAction {
+    type = LibraryActionTypes.Create;
+}
+export class NavigateLibraryAction {
+    payload;
+    route;
+    type = LibraryActionTypes.Navigate;
+    constructor(payload, route) {
+        this.payload = payload;
+        this.route = route;
+    }
+}
+export class UpdateLibraryAction {
+    payload;
+    type = LibraryActionTypes.Update;
+    constructor(payload) {
+        this.payload = payload;
+    }
+}
+export class LeaveLibraryAction {
+    payload;
+    configuration;
+    type = LibraryActionTypes.Leave;
+    constructor(payload, configuration) {
+        this.payload = payload;
+        this.configuration = configuration;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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