@alfresco/aca-shared 5.1.1 → 6.0.0-11114941325

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/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/{esm2020/store/actions/search-ai.actions.mjs → esm2022/store/actions/contextmenu.actions.mjs}

@@ -21,21 +21,12 @@
  * 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 SearchAiActionTypes;
-(function (SearchAiActionTypes) {
-    SearchAiActionTypes["SearchByTermAi"] = "SEARCH_BY_TERM_AI";
-    SearchAiActionTypes["ToggleAiSearchInput"] = "TOGGLE_AI_SEARCH_INPUT";
-})(SearchAiActionTypes || (SearchAiActionTypes = {}));
-export class SearchByTermAiAction {
-    constructor(payload) {
-        this.payload = payload;
-        this.type = SearchAiActionTypes.SearchByTermAi;
+import { ContextMenuActionTypes } from './context-menu-action-types';
+export class ContextMenu {
+    event;
+    type = ContextMenuActionTypes.ContextMenu;
+    constructor(event) {
+        this.event = event;
     }
 }
-export class ToggleAISearchInput {
-    constructor(agentId) {
-        this.agentId = agentId;
-        this.type = SearchAiActionTypes.ToggleAiSearchInput;
-    }
-}
-//# sourceMappingURL=data:application/json;base64,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
+//# 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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

package/esm2022/store/actions/metadata-aspect.actions.mjs

@@ -0,0 +1,32 @@
+/*!
+ * 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 const SET_INFO_DRAWER_METADATA_ASPECT = 'SET_INFO_DRAWER_METADATA_ASPECT';
+export class SetInfoDrawerMetadataAspectAction {
+    payload;
+    type = SET_INFO_DRAWER_METADATA_ASPECT;
+    constructor(payload) {
+        this.payload = payload;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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