@alfresco/adf-content-services 8.1.0-16295066092 → 8.1.0-16320806191

package/esm2022/lib/document-list/components/content-action/content-action-list.component.mjs

@@ -0,0 +1,60 @@
+/*!
+ * @license
+ * Copyright © 2005-2025 Hyland Software, Inc. and its affiliates. All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+/* eslint-disable @angular-eslint/component-selector */
+import { Component } from '@angular/core';
+import { DocumentListComponent } from './../document-list.component';
+import * as i0 from "@angular/core";
+import * as i1 from "./../document-list.component";
+export class ContentActionListComponent {
+    constructor(documentList) {
+        this.documentList = documentList;
+    }
+    /**
+     * Registers action handler within the parent document list component.
+     *
+     * @param action Action model to register.
+     * @returns `true` if actions was registered, otherwise `false`
+     */
+    registerAction(action) {
+        if (this.documentList && action) {
+            this.documentList.actions.push(action);
+            return true;
+        }
+        return false;
+    }
+    unregisterAction(action) {
+        if (this.documentList && action) {
+            const idx = this.documentList.actions.indexOf(action);
+            if (idx >= 0) {
+                this.documentList.actions.splice(idx, 1);
+                return true;
+            }
+        }
+        return false;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: ContentActionListComponent, deps: [{ token: i1.DocumentListComponent }], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "18.2.13", type: ContentActionListComponent, isStandalone: true, selector: "content-actions", ngImport: i0, template: '', isInline: true }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: ContentActionListComponent, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'content-actions',
+                    template: '',
+                    standalone: true
+                }]
+        }], ctorParameters: () => [{ type: i1.DocumentListComponent }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/document-list/components/content-action/content-action.component.mjs

@@ -0,0 +1,196 @@
+/*!
+ * @license
+ * Copyright © 2005-2025 Hyland Software, Inc. and its affiliates. All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+/* eslint-disable @angular-eslint/component-selector */
+import { Component, EventEmitter, Input, Output } from '@angular/core';
+import { DocumentActionsService } from '../../services/document-actions.service';
+import { FolderActionsService } from '../../services/folder-actions.service';
+import { ContentActionModel, ContentActionTarget } from './../../models/content-action.model';
+import { ContentActionListComponent } from './content-action-list.component';
+import * as i0 from "@angular/core";
+import * as i1 from "./content-action-list.component";
+import * as i2 from "../../services/document-actions.service";
+import * as i3 from "../../services/folder-actions.service";
+export class ContentActionComponent {
+    constructor(list, documentActions, folderActions) {
+        this.list = list;
+        this.documentActions = documentActions;
+        this.folderActions = folderActions;
+        /** The title of the action as shown in the menu. */
+        this.title = 'Action';
+        /** Visibility state (see examples). */
+        this.visible = true;
+        /** Type of item that the action applies to. Can be "document" or "folder" */
+        this.target = ContentActionTarget.All;
+        /** Is the menu item disabled? */
+        this.disabled = false;
+        /** Emitted when the user selects the action from the menu. */
+        this.execute = new EventEmitter();
+        /** Emitted when a permission error occurs */
+        this.permissionEvent = new EventEmitter();
+        /**
+         * Emitted when an error occurs during the action.
+         * Applies to copy and move actions.
+         */
+        this.error = new EventEmitter();
+        /**
+         * Emitted when the action succeeds with the success string message.
+         * Applies to copy, move and delete actions.
+         */
+        this.success = new EventEmitter();
+        this.subscriptions = [];
+    }
+    ngOnInit() {
+        if (this.target === ContentActionTarget.All) {
+            this.folderActionModel = this.generateAction(ContentActionTarget.Folder);
+            this.documentActionModel = this.generateAction(ContentActionTarget.Document);
+        }
+        else {
+            this.documentActionModel = this.generateAction(this.target);
+        }
+    }
+    ngOnChanges(changes) {
+        if (changes.visible && !changes.visible.firstChange) {
+            if (this.documentActionModel) {
+                this.documentActionModel.visible = changes.visible.currentValue;
+            }
+            if (this.folderActionModel) {
+                this.folderActionModel.visible = changes.visible.currentValue;
+            }
+        }
+        if (changes.disabled && !changes.disabled.firstChange) {
+            if (this.documentActionModel) {
+                this.documentActionModel.disabled = changes.disabled.currentValue;
+            }
+            if (this.folderActionModel) {
+                this.folderActionModel.disabled = changes.disabled.currentValue;
+            }
+        }
+    }
+    ngOnDestroy() {
+        this.subscriptions.forEach((subscription) => subscription.unsubscribe());
+        this.subscriptions = [];
+        if (this.documentActionModel) {
+            this.unregister(this.documentActionModel);
+            this.documentActionModel = null;
+        }
+        if (this.folderActionModel) {
+            this.unregister(this.folderActionModel);
+            this.folderActionModel = null;
+        }
+    }
+    register(model) {
+        if (this.list) {
+            return this.list.registerAction(model);
+        }
+        return false;
+    }
+    unregister(model) {
+        if (this.list) {
+            return this.list.unregisterAction(model);
+        }
+        return false;
+    }
+    generateAction(target) {
+        const model = new ContentActionModel({
+            title: this.title,
+            icon: this.icon,
+            permission: this.permission,
+            disableWithNoPermission: this.disableWithNoPermission,
+            target,
+            disabled: this.disabled,
+            visible: this.visible
+        });
+        if (this.handler) {
+            model.handler = this.getSystemHandler(target, this.handler);
+        }
+        if (this.execute) {
+            model.execute = (value) => {
+                this.execute.emit({ value });
+            };
+        }
+        this.register(model);
+        return model;
+    }
+    getSystemHandler(target, name) {
+        if (target) {
+            target = target.toLowerCase();
+            if (target === ContentActionTarget.Document) {
+                if (this.documentActions) {
+                    this.subscriptions.push(this.documentActions.permissionEvent.subscribe((permission) => {
+                        this.permissionEvent.emit(permission);
+                    }), this.documentActions.error.subscribe((errors) => {
+                        this.error.emit(errors);
+                    }), this.documentActions.success.subscribe((message) => {
+                        this.success.emit(message);
+                    }));
+                    return this.documentActions.getHandler(name);
+                }
+                return null;
+            }
+            if (target === ContentActionTarget.Folder) {
+                if (this.folderActions) {
+                    this.subscriptions.push(this.folderActions.permissionEvent.subscribe((permission) => {
+                        this.permissionEvent.emit(permission);
+                    }), this.folderActions.error.subscribe((errors) => {
+                        this.error.emit(errors);
+                    }), this.folderActions.success.subscribe((message) => {
+                        this.success.emit(message);
+                    }));
+                    return this.folderActions.getHandler(name);
+                }
+                return null;
+            }
+        }
+        return null;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: ContentActionComponent, deps: [{ token: i1.ContentActionListComponent }, { token: i2.DocumentActionsService }, { token: i3.FolderActionsService }], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "18.2.13", type: ContentActionComponent, isStandalone: true, selector: "content-action", inputs: { title: "title", icon: "icon", visible: "visible", handler: "handler", target: "target", permission: "permission", disableWithNoPermission: "disableWithNoPermission", disabled: "disabled" }, outputs: { execute: "execute", permissionEvent: "permissionEvent", error: "error", success: "success" }, providers: [DocumentActionsService, FolderActionsService], usesOnChanges: true, ngImport: i0, template: '', isInline: true }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: ContentActionComponent, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'content-action',
+                    standalone: true,
+                    template: '',
+                    providers: [DocumentActionsService, FolderActionsService]
+                }]
+        }], ctorParameters: () => [{ type: i1.ContentActionListComponent }, { type: i2.DocumentActionsService }, { type: i3.FolderActionsService }], propDecorators: { title: [{
+                type: Input
+            }], icon: [{
+                type: Input
+            }], visible: [{
+                type: Input
+            }], handler: [{
+                type: Input
+            }], target: [{
+                type: Input
+            }], permission: [{
+                type: Input
+            }], disableWithNoPermission: [{
+                type: Input
+            }], disabled: [{
+                type: Input
+            }], execute: [{
+                type: Output
+            }], permissionEvent: [{
+                type: Output
+            }], error: [{
+                type: Output
+            }], success: [{
+                type: Output
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"content-action.component.js","sourceRoot":"","sources":["../../../../../../../../lib/content-services/src/lib/document-list/components/content-action/content-action.component.ts"],"names":[],"mappings":"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","sourcesContent":["/*!\n * @license\n * Copyright © 2005-2025 Hyland Software, Inc. and its affiliates. All rights reserved.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *     http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\n/* eslint-disable @angular-eslint/component-selector */\n\nimport { Component, EventEmitter, Input, OnInit, Output, OnChanges, SimpleChanges, OnDestroy } from '@angular/core';\n\nimport { ContentActionHandler } from '../../models/content-action.model';\nimport { DocumentActionsService } from '../../services/document-actions.service';\nimport { FolderActionsService } from '../../services/folder-actions.service';\nimport { ContentActionModel, ContentActionTarget } from './../../models/content-action.model';\nimport { ContentActionListComponent } from './content-action-list.component';\nimport { Subscription } from 'rxjs';\n\n@Component({\n    selector: 'content-action',\n    standalone: true,\n    template: '',\n    providers: [DocumentActionsService, FolderActionsService]\n})\nexport class ContentActionComponent implements OnInit, OnChanges, OnDestroy {\n    /** The title of the action as shown in the menu. */\n    @Input()\n    title: string = 'Action';\n\n    /** The name of the icon to display next to the menu command (can be left blank). */\n    @Input()\n    icon: string;\n\n    /** Visibility state (see examples). */\n    @Input()\n    visible: boolean | ((...args) => boolean) = true;\n\n    /** System actions. Can be \"delete\", \"download\", \"copy\" or \"move\". */\n    @Input()\n    handler: string;\n\n    /** Type of item that the action applies to. Can be \"document\" or \"folder\" */\n    @Input()\n    target: string = ContentActionTarget.All;\n\n    /** The permission type. */\n    @Input()\n    permission: string;\n\n    /** Should this action be disabled in the menu if the user doesn't have permission for it? */\n    @Input()\n    disableWithNoPermission: boolean;\n\n    /** Is the menu item disabled? */\n    @Input()\n    disabled: boolean | ((...args) => boolean) = false;\n\n    /** Emitted when the user selects the action from the menu. */\n    @Output()\n    execute = new EventEmitter();\n\n    /** Emitted when a permission error occurs */\n    @Output()\n    permissionEvent = new EventEmitter();\n\n    /**\n     * Emitted when an error occurs during the action.\n     * Applies to copy and move actions.\n     */\n    @Output()\n    error = new EventEmitter();\n\n    /**\n     * Emitted when the action succeeds with the success string message.\n     * Applies to copy, move and delete actions.\n     */\n    @Output()\n    success = new EventEmitter();\n\n    documentActionModel: ContentActionModel;\n    folderActionModel: ContentActionModel;\n\n    private subscriptions: Subscription[] = [];\n\n    constructor(\n        private list: ContentActionListComponent,\n        private documentActions: DocumentActionsService,\n        private folderActions: FolderActionsService\n    ) {}\n\n    ngOnInit() {\n        if (this.target === ContentActionTarget.All) {\n            this.folderActionModel = this.generateAction(ContentActionTarget.Folder);\n            this.documentActionModel = this.generateAction(ContentActionTarget.Document);\n        } else {\n            this.documentActionModel = this.generateAction(this.target);\n        }\n    }\n\n    ngOnChanges(changes: SimpleChanges) {\n        if (changes.visible && !changes.visible.firstChange) {\n            if (this.documentActionModel) {\n                this.documentActionModel.visible = changes.visible.currentValue;\n            }\n            if (this.folderActionModel) {\n                this.folderActionModel.visible = changes.visible.currentValue;\n            }\n        }\n\n        if (changes.disabled && !changes.disabled.firstChange) {\n            if (this.documentActionModel) {\n                this.documentActionModel.disabled = changes.disabled.currentValue;\n            }\n            if (this.folderActionModel) {\n                this.folderActionModel.disabled = changes.disabled.currentValue;\n            }\n        }\n    }\n\n    ngOnDestroy() {\n        this.subscriptions.forEach((subscription) => subscription.unsubscribe());\n        this.subscriptions = [];\n\n        if (this.documentActionModel) {\n            this.unregister(this.documentActionModel);\n            this.documentActionModel = null;\n        }\n\n        if (this.folderActionModel) {\n            this.unregister(this.folderActionModel);\n            this.folderActionModel = null;\n        }\n    }\n\n    register(model: ContentActionModel): boolean {\n        if (this.list) {\n            return this.list.registerAction(model);\n        }\n        return false;\n    }\n\n    unregister(model: ContentActionModel): boolean {\n        if (this.list) {\n            return this.list.unregisterAction(model);\n        }\n        return false;\n    }\n\n    private generateAction(target: string): ContentActionModel {\n        const model = new ContentActionModel({\n            title: this.title,\n            icon: this.icon,\n            permission: this.permission,\n            disableWithNoPermission: this.disableWithNoPermission,\n            target,\n            disabled: this.disabled,\n            visible: this.visible\n        });\n        if (this.handler) {\n            model.handler = this.getSystemHandler(target, this.handler);\n        }\n\n        if (this.execute) {\n            model.execute = (value: any): void => {\n                this.execute.emit({ value });\n            };\n        }\n\n        this.register(model);\n        return model;\n    }\n\n    getSystemHandler(target: string, name: string): ContentActionHandler {\n        if (target) {\n            target = target.toLowerCase();\n\n            if (target === ContentActionTarget.Document) {\n                if (this.documentActions) {\n                    this.subscriptions.push(\n                        this.documentActions.permissionEvent.subscribe((permission) => {\n                            this.permissionEvent.emit(permission);\n                        }),\n                        this.documentActions.error.subscribe((errors) => {\n                            this.error.emit(errors);\n                        }),\n                        this.documentActions.success.subscribe((message) => {\n                            this.success.emit(message);\n                        })\n                    );\n\n                    return this.documentActions.getHandler(name);\n                }\n                return null;\n            }\n\n            if (target === ContentActionTarget.Folder) {\n                if (this.folderActions) {\n                    this.subscriptions.push(\n                        this.folderActions.permissionEvent.subscribe((permission) => {\n                            this.permissionEvent.emit(permission);\n                        }),\n                        this.folderActions.error.subscribe((errors) => {\n                            this.error.emit(errors);\n                        }),\n                        this.folderActions.success.subscribe((message) => {\n                            this.success.emit(message);\n                        })\n                    );\n\n                    return this.folderActions.getHandler(name);\n                }\n                return null;\n            }\n        }\n        return null;\n    }\n}\n"]}