@alfresco/adf-process-services 6.10.0-9207260694 → 6.10.0-9207592672

package/esm2020/lib/app-list/apps-list.module.mjs

@@ -0,0 +1,37 @@
+/*!
+ * @license
+ * Copyright © 2005-2024 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.
+ */
+import { NgModule } from '@angular/core';
+import { AppsListComponent } from './apps-list.component';
+import { SelectAppsDialogComponent } from './select-apps-dialog.component';
+import * as i0 from "@angular/core";
+/**
+ * @deprecated this Module is deprecated and should no longer be used.
+ * Consider importing components directly instead.
+ */
+export class AppsListModule {
+}
+AppsListModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.1.3", ngImport: i0, type: AppsListModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+AppsListModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "14.1.3", ngImport: i0, type: AppsListModule, imports: [AppsListComponent, SelectAppsDialogComponent], exports: [AppsListComponent, SelectAppsDialogComponent] });
+AppsListModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "14.1.3", ngImport: i0, type: AppsListModule, imports: [AppsListComponent, SelectAppsDialogComponent] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.1.3", ngImport: i0, type: AppsListModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    imports: [AppsListComponent, SelectAppsDialogComponent],
+                    exports: [AppsListComponent, SelectAppsDialogComponent]
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/app-list/public-api.mjs

@@ -14,10 +14,8 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import { AppsListComponent } from './apps-list.component';
-import { SelectAppsDialogComponent } from './select-apps-dialog/select-apps-dialog.component';
 export * from './apps-list.component';
-export * from './select-apps-dialog/select-apps-dialog.component';
+export * from './select-apps-dialog.component';
 export * from './services/apps-process.service';
-export const APPS_LIST_DIRECTIVES = [AppsListComponent, SelectAppsDialogComponent];
-//# sourceMappingURL=data:application/json;base64,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
+export * from './apps-list.module';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHVibGljLWFwaS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uL2xpYi9wcm9jZXNzLXNlcnZpY2VzL3NyYy9saWIvYXBwLWxpc3QvcHVibGljLWFwaS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQTs7Ozs7Ozs7Ozs7Ozs7O0dBZUc7QUFFSCxjQUFjLHVCQUF1QixDQUFDO0FBQ3RDLGNBQWMsZ0NBQWdDLENBQUM7QUFFL0MsY0FBYyxpQ0FBaUMsQ0FBQztBQUVoRCxjQUFjLG9CQUFvQixDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiLyohXG4gKiBAbGljZW5zZVxuICogQ29weXJpZ2h0IMKpIDIwMDUtMjAyNCBIeWxhbmQgU29mdHdhcmUsIEluYy4gYW5kIGl0cyBhZmZpbGlhdGVzLiBBbGwgcmlnaHRzIHJlc2VydmVkLlxuICpcbiAqIExpY2Vuc2VkIHVuZGVyIHRoZSBBcGFjaGUgTGljZW5zZSwgVmVyc2lvbiAyLjAgKHRoZSBcIkxpY2Vuc2VcIik7XG4gKiB5b3UgbWF5IG5vdCB1c2UgdGhpcyBmaWxlIGV4Y2VwdCBpbiBjb21wbGlhbmNlIHdpdGggdGhlIExpY2Vuc2UuXG4gKiBZb3UgbWF5IG9idGFpbiBhIGNvcHkgb2YgdGhlIExpY2Vuc2UgYXRcbiAqXG4gKiAgICAgaHR0cDovL3d3dy5hcGFjaGUub3JnL2xpY2Vuc2VzL0xJQ0VOU0UtMi4wXG4gKlxuICogVW5sZXNzIHJlcXVpcmVkIGJ5IGFwcGxpY2FibGUgbGF3IG9yIGFncmVlZCB0byBpbiB3cml0aW5nLCBzb2Z0d2FyZVxuICogZGlzdHJpYnV0ZWQgdW5kZXIgdGhlIExpY2Vuc2UgaXMgZGlzdHJpYnV0ZWQgb24gYW4gXCJBUyBJU1wiIEJBU0lTLFxuICogV0lUSE9VVCBXQVJSQU5USUVTIE9SIENPTkRJVElPTlMgT0YgQU5ZIEtJTkQsIGVpdGhlciBleHByZXNzIG9yIGltcGxpZWQuXG4gKiBTZWUgdGhlIExpY2Vuc2UgZm9yIHRoZSBzcGVjaWZpYyBsYW5ndWFnZSBnb3Zlcm5pbmcgcGVybWlzc2lvbnMgYW5kXG4gKiBsaW1pdGF0aW9ucyB1bmRlciB0aGUgTGljZW5zZS5cbiAqL1xuXG5leHBvcnQgKiBmcm9tICcuL2FwcHMtbGlzdC5jb21wb25lbnQnO1xuZXhwb3J0ICogZnJvbSAnLi9zZWxlY3QtYXBwcy1kaWFsb2cuY29tcG9uZW50JztcblxuZXhwb3J0ICogZnJvbSAnLi9zZXJ2aWNlcy9hcHBzLXByb2Nlc3Muc2VydmljZSc7XG5cbmV4cG9ydCAqIGZyb20gJy4vYXBwcy1saXN0Lm1vZHVsZSc7XG4iXX0=

package/esm2020/lib/app-list/{select-apps-dialog/select-apps-dialog.component.mjs → select-apps-dialog.component.mjs}

@@ -16,13 +16,13 @@
  */
 import { Component, Inject, ViewEncapsulation } from '@angular/core';
 import { MAT_DIALOG_DATA, MatDialogModule, MatDialogRef } from '@angular/material/dialog';
-import { AppsProcessService } from '../services/apps-process.service';
+import { AppsProcessService } from './services/apps-process.service';
 import { CommonModule } from '@angular/common';
 import { TranslateModule } from '@ngx-translate/core';
 import { MatSelectModule } from '@angular/material/select';
 import { MatButtonModule } from '@angular/material/button';
 import * as i0 from "@angular/core";
-import * as i1 from "../services/apps-process.service";
+import * as i1 from "./services/apps-process.service";
 import * as i2 from "@angular/material/dialog";
 import * as i3 from "@angular/common";
 import * as i4 from "@ngx-translate/core";
@@ -51,4 +51,4 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.1.3", ngImpor
                     type: Inject,
                     args: [MAT_DIALOG_DATA]
                 }] }]; } });
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/app-list/services/apps-process.service.mjs

@@ -17,10 +17,10 @@
 import { Injectable } from '@angular/core';
 import { RuntimeAppDefinitionsApi } from '@alfresco/js-api';
 import { from } from 'rxjs';
-import { AlfrescoApiService } from '@alfresco/adf-core';
+import { AlfrescoApiService } from '@alfresco/adf-content-services';
 import { map } from 'rxjs/operators';
 import * as i0 from "@angular/core";
-import * as i1 from "@alfresco/adf-core";
+import * as i1 from "@alfresco/adf-content-services";
 export class AppsProcessService {
     constructor(apiService) {
         this.apiService = apiService;
@@ -55,4 +55,4 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.1.3", ngImpor
                     providedIn: 'root'
                 }]
         }], ctorParameters: function () { return [{ type: i1.AlfrescoApiService }]; } });
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYXBwcy1wcm9jZXNzLnNlcnZpY2UuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi9saWIvcHJvY2Vzcy1zZXJ2aWNlcy9zcmMvbGliL2FwcC1saXN0L3NlcnZpY2VzL2FwcHMtcHJvY2Vzcy5zZXJ2aWNlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOzs7Ozs7Ozs7Ozs7Ozs7R0FlRztBQUVILE9BQU8sRUFBRSxVQUFVLEVBQUUsTUFBTSxlQUFlLENBQUM7QUFDM0MsT0FBTyxFQUFFLHdCQUF3QixFQUErQixNQUFNLGtCQUFrQixDQUFDO0FBQ3pGLE9BQU8sRUFBYyxJQUFJLEVBQUUsTUFBTSxNQUFNLENBQUM7QUFDeEMsT0FBTyxFQUFFLGtCQUFrQixFQUFFLE1BQU0sb0JBQW9CLENBQUM7QUFDeEQsT0FBTyxFQUFFLEdBQUcsRUFBRSxNQUFNLGdCQUFnQixDQUFDOzs7QUFLckMsTUFBTSxPQUFPLGtCQUFrQjtJQU8zQixZQUFvQixVQUE4QjtRQUE5QixlQUFVLEdBQVYsVUFBVSxDQUFvQjtJQUFHLENBQUM7SUFMdEQsSUFBSSxPQUFPO1FBQ1AsSUFBSSxDQUFDLFFBQVEsR0FBRyxJQUFJLENBQUMsUUFBUSxJQUFJLElBQUksd0JBQXdCLENBQUMsSUFBSSxDQUFDLFVBQVUsQ0FBQyxXQUFXLEVBQUUsQ0FBQyxDQUFDO1FBQzdGLE9BQU8sSUFBSSxDQUFDLFFBQVEsQ0FBQztJQUN6QixDQUFDO0lBSUQ7Ozs7T0FJRztJQUNILHVCQUF1QjtRQUNuQixPQUFPLElBQUksQ0FBQyxJQUFJLENBQUMsT0FBTyxDQUFDLGlCQUFpQixFQUFFLENBQUMsQ0FBQyxJQUFJLENBQUMsR0FBRyxDQUFDLENBQUMsUUFBUSxFQUFFLEVBQUUsQ0FBQyxRQUFRLENBQUMsSUFBSSxJQUFJLEVBQUUsQ0FBQyxDQUFDLENBQUM7SUFDL0YsQ0FBQztJQUVEOzs7OztPQUtHO0lBQ0gsNkJBQTZCLENBQUMsSUFBWTtRQUN0QyxPQUFPLElBQUksQ0FBQyx1QkFBdUIsRUFBRSxDQUFDLElBQUksQ0FBQyxHQUFHLENBQUMsQ0FBQyxRQUFRLEVBQUUsRUFBRSxDQUFDLFFBQVEsQ0FBQyxJQUFJLENBQUMsQ0FBQyxHQUFHLEVBQUUsRUFBRSxDQUFDLEdBQUcsQ0FBQyxJQUFJLEtBQUssSUFBSSxDQUFDLENBQUMsQ0FBQyxDQUFDO0lBQzdHLENBQUM7OytHQTFCUSxrQkFBa0I7bUhBQWxCLGtCQUFrQixjQUZmLE1BQU07MkZBRVQsa0JBQWtCO2tCQUg5QixVQUFVO21CQUFDO29CQUNSLFVBQVUsRUFBRSxNQUFNO2lCQUNyQiIsInNvdXJjZXNDb250ZW50IjpbIi8qIVxuICogQGxpY2Vuc2VcbiAqIENvcHlyaWdodCDCqSAyMDA1LTIwMjQgSHlsYW5kIFNvZnR3YXJlLCBJbmMuIGFuZCBpdHMgYWZmaWxpYXRlcy4gQWxsIHJpZ2h0cyByZXNlcnZlZC5cbiAqXG4gKiBMaWNlbnNlZCB1bmRlciB0aGUgQXBhY2hlIExpY2Vuc2UsIFZlcnNpb24gMi4wICh0aGUgXCJMaWNlbnNlXCIpO1xuICogeW91IG1heSBub3QgdXNlIHRoaXMgZmlsZSBleGNlcHQgaW4gY29tcGxpYW5jZSB3aXRoIHRoZSBMaWNlbnNlLlxuICogWW91IG1heSBvYnRhaW4gYSBjb3B5IG9mIHRoZSBMaWNlbnNlIGF0XG4gKlxuICogICAgIGh0dHA6Ly93d3cuYXBhY2hlLm9yZy9saWNlbnNlcy9MSUNFTlNFLTIuMFxuICpcbiAqIFVubGVzcyByZXF1aXJlZCBieSBhcHBsaWNhYmxlIGxhdyBvciBhZ3JlZWQgdG8gaW4gd3JpdGluZywgc29mdHdhcmVcbiAqIGRpc3RyaWJ1dGVkIHVuZGVyIHRoZSBMaWNlbnNlIGlzIGRpc3RyaWJ1dGVkIG9uIGFuIFwiQVMgSVNcIiBCQVNJUyxcbiAqIFdJVEhPVVQgV0FSUkFOVElFUyBPUiBDT05ESVRJT05TIE9GIEFOWSBLSU5ELCBlaXRoZXIgZXhwcmVzcyBvciBpbXBsaWVkLlxuICogU2VlIHRoZSBMaWNlbnNlIGZvciB0aGUgc3BlY2lmaWMgbGFuZ3VhZ2UgZ292ZXJuaW5nIHBlcm1pc3Npb25zIGFuZFxuICogbGltaXRhdGlvbnMgdW5kZXIgdGhlIExpY2Vuc2UuXG4gKi9cblxuaW1wb3J0IHsgSW5qZWN0YWJsZSB9IGZyb20gJ0Bhbmd1bGFyL2NvcmUnO1xuaW1wb3J0IHsgUnVudGltZUFwcERlZmluaXRpb25zQXBpLCBBcHBEZWZpbml0aW9uUmVwcmVzZW50YXRpb24gfSBmcm9tICdAYWxmcmVzY28vanMtYXBpJztcbmltcG9ydCB7IE9ic2VydmFibGUsIGZyb20gfSBmcm9tICdyeGpzJztcbmltcG9ydCB7IEFsZnJlc2NvQXBpU2VydmljZSB9IGZyb20gJ0BhbGZyZXNjby9hZGYtY29yZSc7XG5pbXBvcnQgeyBtYXAgfSBmcm9tICdyeGpzL29wZXJhdG9ycyc7XG5cbkBJbmplY3RhYmxlKHtcbiAgICBwcm92aWRlZEluOiAncm9vdCdcbn0pXG5leHBvcnQgY2xhc3MgQXBwc1Byb2Nlc3NTZXJ2aWNlIHtcbiAgICBwcml2YXRlIF9hcHBzQXBpOiBSdW50aW1lQXBwRGVmaW5pdGlvbnNBcGk7XG4gICAgZ2V0IGFwcHNBcGkoKTogUnVudGltZUFwcERlZmluaXRpb25zQXBpIHtcbiAgICAgICAgdGhpcy5fYXBwc0FwaSA9IHRoaXMuX2FwcHNBcGkgPz8gbmV3IFJ1bnRpbWVBcHBEZWZpbml0aW9uc0FwaSh0aGlzLmFwaVNlcnZpY2UuZ2V0SW5zdGFuY2UoKSk7XG4gICAgICAgIHJldHVybiB0aGlzLl9hcHBzQXBpO1xuICAgIH1cblxuICAgIGNvbnN0cnVjdG9yKHByaXZhdGUgYXBpU2VydmljZTogQWxmcmVzY29BcGlTZXJ2aWNlKSB7fVxuXG4gICAgLyoqXG4gICAgICogR2V0cyBhIGxpc3Qgb2YgZGVwbG95ZWQgYXBwcyBmb3IgdGhpcyB1c2VyLlxuICAgICAqXG4gICAgICogQHJldHVybnMgVGhlIGxpc3Qgb2YgZGVwbG95ZWQgYXBwc1xuICAgICAqL1xuICAgIGdldERlcGxveWVkQXBwbGljYXRpb25zKCk6IE9ic2VydmFibGU8QXBwRGVmaW5pdGlvblJlcHJlc2VudGF0aW9uW10+IHtcbiAgICAgICAgcmV0dXJuIGZyb20odGhpcy5hcHBzQXBpLmdldEFwcERlZmluaXRpb25zKCkpLnBpcGUobWFwKChyZXNwb25zZSkgPT4gcmVzcG9uc2UuZGF0YSB8fCBbXSkpO1xuICAgIH1cblxuICAgIC8qKlxuICAgICAqIEdldHMgYSBsaXN0IG9mIGRlcGxveWVkIGFwcHMgZm9yIHRoaXMgdXNlciwgd2hlcmUgdGhlIGFwcCBuYW1lIGlzIGBuYW1lYC5cbiAgICAgKlxuICAgICAqIEBwYXJhbSBuYW1lIE5hbWUgb2YgdGhlIGFwcFxuICAgICAqIEByZXR1cm5zIFRoZSBsaXN0IG9mIGRlcGxveWVkIGFwcHNcbiAgICAgKi9cbiAgICBnZXREZXBsb3llZEFwcGxpY2F0aW9uc0J5TmFtZShuYW1lOiBzdHJpbmcpOiBPYnNlcnZhYmxlPEFwcERlZmluaXRpb25SZXByZXNlbnRhdGlvbj4ge1xuICAgICAgICByZXR1cm4gdGhpcy5nZXREZXBsb3llZEFwcGxpY2F0aW9ucygpLnBpcGUobWFwKChyZXNwb25zZSkgPT4gcmVzcG9uc2UuZmluZCgoYXBwKSA9PiBhcHAubmFtZSA9PT0gbmFtZSkpKTtcbiAgICB9XG59XG4iXX0=
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/attachment/attachment.module.mjs

@@ -0,0 +1,63 @@
+/*!
+ * @license
+ * Copyright © 2005-2024 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.
+ */
+import { NgModule } from '@angular/core';
+import { MaterialModule } from '../material.module';
+import { TaskAttachmentListComponent } from './task-attachment-list.component';
+import { ProcessAttachmentListComponent } from './process-attachment-list.component';
+import { CreateProcessAttachmentComponent } from './create-process-attachment.component';
+import { AttachmentComponent } from './create-task-attachment.component';
+import { CoreModule } from '@alfresco/adf-core';
+import * as i0 from "@angular/core";
+export class AttachmentModule {
+}
+AttachmentModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.1.3", ngImport: i0, type: AttachmentModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+AttachmentModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "14.1.3", ngImport: i0, type: AttachmentModule, declarations: [TaskAttachmentListComponent,
+        ProcessAttachmentListComponent,
+        CreateProcessAttachmentComponent,
+        CreateProcessAttachmentComponent,
+        AttachmentComponent], imports: [CoreModule,
+        MaterialModule], exports: [TaskAttachmentListComponent,
+        ProcessAttachmentListComponent,
+        CreateProcessAttachmentComponent,
+        CreateProcessAttachmentComponent,
+        AttachmentComponent] });
+AttachmentModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "14.1.3", ngImport: i0, type: AttachmentModule, imports: [CoreModule,
+        MaterialModule] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.1.3", ngImport: i0, type: AttachmentModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    imports: [
+                        CoreModule,
+                        MaterialModule
+                    ],
+                    declarations: [
+                        TaskAttachmentListComponent,
+                        ProcessAttachmentListComponent,
+                        CreateProcessAttachmentComponent,
+                        CreateProcessAttachmentComponent,
+                        AttachmentComponent
+                    ],
+                    exports: [
+                        TaskAttachmentListComponent,
+                        ProcessAttachmentListComponent,
+                        CreateProcessAttachmentComponent,
+                        CreateProcessAttachmentComponent,
+                        AttachmentComponent
+                    ]
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/attachment/create-process-attachment.component.mjs

@@ -0,0 +1,70 @@
+/*!
+ * @license
+ * Copyright © 2005-2024 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.
+ */
+import { Component, EventEmitter, Input, Output } from '@angular/core';
+import { ProcessContentService } from '../form/services/process-content.service';
+import * as i0 from "@angular/core";
+import * as i1 from "../form/services/process-content.service";
+import * as i2 from "@alfresco/adf-core";
+import * as i3 from "@angular/material/button";
+import * as i4 from "@angular/material/icon";
+export class CreateProcessAttachmentComponent {
+    constructor(processContentService) {
+        this.processContentService = processContentService;
+        /**
+         * Emitted when an error occurs while creating or uploading an attachment
+         * from the user within the component.
+         */
+        this.error = new EventEmitter();
+        /**
+         * Emitted when an attachment is successfully created or uploaded
+         * from within the component.
+         */
+        this.success = new EventEmitter();
+    }
+    ngOnChanges(changes) {
+        if (changes['processInstanceId']?.currentValue) {
+            this.processInstanceId = changes['processInstanceId'].currentValue;
+        }
+    }
+    onFileUpload(event) {
+        const filesList = event.detail.files.map((obj) => obj.file);
+        for (const fileInfoObj of filesList) {
+            const file = fileInfoObj;
+            const opts = {
+                isRelatedContent: true
+            };
+            this.processContentService.createProcessRelatedContent(this.processInstanceId, file, opts).subscribe((res) => {
+                this.success.emit(res);
+            }, (err) => {
+                this.error.emit(err);
+            });
+        }
+    }
+}
+CreateProcessAttachmentComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.1.3", ngImport: i0, type: CreateProcessAttachmentComponent, deps: [{ token: i1.ProcessContentService }], target: i0.ɵɵFactoryTarget.Component });
+CreateProcessAttachmentComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "14.1.3", type: CreateProcessAttachmentComponent, selector: "adf-create-process-attachment", inputs: { processInstanceId: "processInstanceId" }, outputs: { error: "error", success: "success" }, usesOnChanges: true, ngImport: i0, template: "<button\n    id=\"add_new_process_content_button\"\n    color=\"primary\"\n    mat-button\n    mat-raised-button\n    mat-icon-button\n    class=\"adf-create-attachment\"\n    [adf-upload]=\"true\"\n    [mode]=\"['click']\"\n    [multiple]=\"true\"\n    (upload-files)=\"onFileUpload($event)\">\n    <mat-icon>add</mat-icon>\n</button>\n", styles: [".adf-create-attachment{display:inline-block;line-height:0;vertical-align:middle}\n"], dependencies: [{ kind: "directive", type: i2.UploadDirective, selector: "[adf-upload]", inputs: ["adf-upload", "adf-upload-data", "mode", "multiple", "accept", "directory"] }, { kind: "component", type: i3.MatButton, selector: "button[mat-button], button[mat-raised-button], button[mat-icon-button],             button[mat-fab], button[mat-mini-fab], button[mat-stroked-button],             button[mat-flat-button]", inputs: ["disabled", "disableRipple", "color"], exportAs: ["matButton"] }, { kind: "component", type: i4.MatIcon, selector: "mat-icon", inputs: ["color", "inline", "svgIcon", "fontSet", "fontIcon"], exportAs: ["matIcon"] }] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.1.3", ngImport: i0, type: CreateProcessAttachmentComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'adf-create-process-attachment', template: "<button\n    id=\"add_new_process_content_button\"\n    color=\"primary\"\n    mat-button\n    mat-raised-button\n    mat-icon-button\n    class=\"adf-create-attachment\"\n    [adf-upload]=\"true\"\n    [mode]=\"['click']\"\n    [multiple]=\"true\"\n    (upload-files)=\"onFileUpload($event)\">\n    <mat-icon>add</mat-icon>\n</button>\n", styles: [".adf-create-attachment{display:inline-block;line-height:0;vertical-align:middle}\n"] }]
+        }], ctorParameters: function () { return [{ type: i1.ProcessContentService }]; }, propDecorators: { processInstanceId: [{
+                type: Input
+            }], error: [{
+                type: Output
+            }], success: [{
+                type: Output
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/attachment/create-task-attachment.component.mjs

@@ -0,0 +1,70 @@
+/*!
+ * @license
+ * Copyright © 2005-2024 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.
+ */
+import { Component, EventEmitter, Input, Output } from '@angular/core';
+import { ProcessContentService } from '../form/services/process-content.service';
+import * as i0 from "@angular/core";
+import * as i1 from "../form/services/process-content.service";
+import * as i2 from "@alfresco/adf-core";
+import * as i3 from "@angular/material/button";
+import * as i4 from "@angular/material/icon";
+export class AttachmentComponent {
+    constructor(processContentService) {
+        this.processContentService = processContentService;
+        /**
+         * Emitted when an error occurs while creating or uploading an
+         *  attachment from the user within the component.
+         */
+        this.error = new EventEmitter();
+        /**
+         * Emitted when an attachment is created or uploaded successfully
+         * from within the component.
+         */
+        this.success = new EventEmitter();
+    }
+    ngOnChanges(changes) {
+        if (changes['taskId']?.currentValue) {
+            this.taskId = changes['taskId'].currentValue;
+        }
+    }
+    onFileUpload(event) {
+        const filesList = event.detail.files.map((obj) => obj.file);
+        for (const fileInfoObj of filesList) {
+            const file = fileInfoObj;
+            const opts = {
+                isRelatedContent: true
+            };
+            this.processContentService.createTaskRelatedContent(this.taskId, file, opts).subscribe((res) => {
+                this.success.emit(res);
+            }, (err) => {
+                this.error.emit(err);
+            });
+        }
+    }
+}
+AttachmentComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.1.3", ngImport: i0, type: AttachmentComponent, deps: [{ token: i1.ProcessContentService }], target: i0.ɵɵFactoryTarget.Component });
+AttachmentComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "14.1.3", type: AttachmentComponent, selector: "adf-create-task-attachment", inputs: { taskId: "taskId" }, outputs: { error: "error", success: "success" }, usesOnChanges: true, ngImport: i0, template: "<button\n    color=\"primary\"\n    mat-button\n    mat-raised-button\n    mat-icon-button\n    class=\"adf-create-attachment\"\n    [adf-upload]=\"true\"\n    [mode]=\"['click']\"\n    [multiple]=\"true\"\n    (upload-files)=\"onFileUpload($event)\">\n    <mat-icon>add</mat-icon>\n</button>\n", styles: [".adf-create-attachment{display:inline-block;line-height:0;vertical-align:middle}\n"], dependencies: [{ kind: "directive", type: i2.UploadDirective, selector: "[adf-upload]", inputs: ["adf-upload", "adf-upload-data", "mode", "multiple", "accept", "directory"] }, { kind: "component", type: i3.MatButton, selector: "button[mat-button], button[mat-raised-button], button[mat-icon-button],             button[mat-fab], button[mat-mini-fab], button[mat-stroked-button],             button[mat-flat-button]", inputs: ["disabled", "disableRipple", "color"], exportAs: ["matButton"] }, { kind: "component", type: i4.MatIcon, selector: "mat-icon", inputs: ["color", "inline", "svgIcon", "fontSet", "fontIcon"], exportAs: ["matIcon"] }] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.1.3", ngImport: i0, type: AttachmentComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'adf-create-task-attachment', template: "<button\n    color=\"primary\"\n    mat-button\n    mat-raised-button\n    mat-icon-button\n    class=\"adf-create-attachment\"\n    [adf-upload]=\"true\"\n    [mode]=\"['click']\"\n    [multiple]=\"true\"\n    (upload-files)=\"onFileUpload($event)\">\n    <mat-icon>add</mat-icon>\n</button>\n", styles: [".adf-create-attachment{display:inline-block;line-height:0;vertical-align:middle}\n"] }]
+        }], ctorParameters: function () { return [{ type: i1.ProcessContentService }]; }, propDecorators: { taskId: [{
+                type: Input
+            }], error: [{
+                type: Output
+            }], success: [{
+                type: Output
+            }] } });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY3JlYXRlLXRhc2stYXR0YWNobWVudC5jb21wb25lbnQuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9saWIvcHJvY2Vzcy1zZXJ2aWNlcy9zcmMvbGliL2F0dGFjaG1lbnQvY3JlYXRlLXRhc2stYXR0YWNobWVudC5jb21wb25lbnQudHMiLCIuLi8uLi8uLi8uLi8uLi8uLi9saWIvcHJvY2Vzcy1zZXJ2aWNlcy9zcmMvbGliL2F0dGFjaG1lbnQvY3JlYXRlLXRhc2stYXR0YWNobWVudC5jb21wb25lbnQuaHRtbCJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQTs7Ozs7Ozs7Ozs7Ozs7O0dBZUc7QUFFSCxPQUFPLEVBQUUsU0FBUyxFQUFFLFlBQVksRUFBRSxLQUFLLEVBQWEsTUFBTSxFQUFpQixNQUFNLGVBQWUsQ0FBQztBQUNqRyxPQUFPLEVBQUUscUJBQXFCLEVBQUUsTUFBTSwwQ0FBMEMsQ0FBQzs7Ozs7O0FBT2pGLE1BQU0sT0FBTyxtQkFBbUI7SUFtQjVCLFlBQW9CLHFCQUE0QztRQUE1QywwQkFBcUIsR0FBckIscUJBQXFCLENBQXVCO1FBZGhFOzs7V0FHRztRQUVILFVBQUssR0FBRyxJQUFJLFlBQVksRUFBTyxDQUFDO1FBRWhDOzs7V0FHRztRQUVILFlBQU8sR0FBRyxJQUFJLFlBQVksRUFBTyxDQUFDO0lBRWlDLENBQUM7SUFFcEUsV0FBVyxDQUFDLE9BQXNCO1FBQzlCLElBQUksT0FBTyxDQUFDLFFBQVEsQ0FBQyxFQUFFLFlBQVksRUFBRTtZQUNqQyxJQUFJLENBQUMsTUFBTSxHQUFHLE9BQU8sQ0FBQyxRQUFRLENBQUMsQ0FBQyxZQUFZLENBQUM7U0FDaEQ7SUFDTCxDQUFDO0lBRUQsWUFBWSxDQUFDLEtBQVU7UUFDbkIsTUFBTSxTQUFTLEdBQVcsS0FBSyxDQUFDLE1BQU0sQ0FBQyxLQUFLLENBQUMsR0FBRyxDQUFDLENBQUMsR0FBRyxFQUFFLEVBQUUsQ0FBQyxHQUFHLENBQUMsSUFBSSxDQUFDLENBQUM7UUFFcEUsS0FBSyxNQUFNLFdBQVcsSUFBSSxTQUFTLEVBQUU7WUFDakMsTUFBTSxJQUFJLEdBQVMsV0FBVyxDQUFDO1lBQy9CLE1BQU0sSUFBSSxHQUFHO2dCQUNULGdCQUFnQixFQUFFLElBQUk7YUFDekIsQ0FBQztZQUNGLElBQUksQ0FBQyxxQkFBcUIsQ0FBQyx3QkFBd0IsQ0FBQyxJQUFJLENBQUMsTUFBTSxFQUFFLElBQUksRUFBRSxJQUFJLENBQUMsQ0FBQyxTQUFTLENBQ2xGLENBQUMsR0FBRyxFQUFFLEVBQUU7Z0JBQ0osSUFBSSxDQUFDLE9BQU8sQ0FBQyxJQUFJLENBQUMsR0FBRyxDQUFDLENBQUM7WUFDM0IsQ0FBQyxFQUNELENBQUMsR0FBRyxFQUFFLEVBQUU7Z0JBQ0osSUFBSSxDQUFDLEtBQUssQ0FBQyxJQUFJLENBQUMsR0FBRyxDQUFDLENBQUM7WUFDekIsQ0FBQyxDQUNKLENBQUM7U0FDTDtJQUNMLENBQUM7O2dIQTVDUSxtQkFBbUI7b0dBQW5CLG1CQUFtQixzS0N6QmhDLHdTQVlBOzJGRGFhLG1CQUFtQjtrQkFML0IsU0FBUzsrQkFDSSw0QkFBNEI7NEdBT3RDLE1BQU07c0JBREwsS0FBSztnQkFRTixLQUFLO3NCQURKLE1BQU07Z0JBUVAsT0FBTztzQkFETixNQUFNIiwic291cmNlc0NvbnRlbnQiOlsiLyohXG4gKiBAbGljZW5zZVxuICogQ29weXJpZ2h0IMKpIDIwMDUtMjAyNCBIeWxhbmQgU29mdHdhcmUsIEluYy4gYW5kIGl0cyBhZmZpbGlhdGVzLiBBbGwgcmlnaHRzIHJlc2VydmVkLlxuICpcbiAqIExpY2Vuc2VkIHVuZGVyIHRoZSBBcGFjaGUgTGljZW5zZSwgVmVyc2lvbiAyLjAgKHRoZSBcIkxpY2Vuc2VcIik7XG4gKiB5b3UgbWF5IG5vdCB1c2UgdGhpcyBmaWxlIGV4Y2VwdCBpbiBjb21wbGlhbmNlIHdpdGggdGhlIExpY2Vuc2UuXG4gKiBZb3UgbWF5IG9idGFpbiBhIGNvcHkgb2YgdGhlIExpY2Vuc2UgYXRcbiAqXG4gKiAgICAgaHR0cDovL3d3dy5hcGFjaGUub3JnL2xpY2Vuc2VzL0xJQ0VOU0UtMi4wXG4gKlxuICogVW5sZXNzIHJlcXVpcmVkIGJ5IGFwcGxpY2FibGUgbGF3IG9yIGFncmVlZCB0byBpbiB3cml0aW5nLCBzb2Z0d2FyZVxuICogZGlzdHJpYnV0ZWQgdW5kZXIgdGhlIExpY2Vuc2UgaXMgZGlzdHJpYnV0ZWQgb24gYW4gXCJBUyBJU1wiIEJBU0lTLFxuICogV0lUSE9VVCBXQVJSQU5USUVTIE9SIENPTkRJVElPTlMgT0YgQU5ZIEtJTkQsIGVpdGhlciBleHByZXNzIG9yIGltcGxpZWQuXG4gKiBTZWUgdGhlIExpY2Vuc2UgZm9yIHRoZSBzcGVjaWZpYyBsYW5ndWFnZSBnb3Zlcm5pbmcgcGVybWlzc2lvbnMgYW5kXG4gKiBsaW1pdGF0aW9ucyB1bmRlciB0aGUgTGljZW5zZS5cbiAqL1xuXG5pbXBvcnQgeyBDb21wb25lbnQsIEV2ZW50RW1pdHRlciwgSW5wdXQsIE9uQ2hhbmdlcywgT3V0cHV0LCBTaW1wbGVDaGFuZ2VzIH0gZnJvbSAnQGFuZ3VsYXIvY29yZSc7XG5pbXBvcnQgeyBQcm9jZXNzQ29udGVudFNlcnZpY2UgfSBmcm9tICcuLi9mb3JtL3NlcnZpY2VzL3Byb2Nlc3MtY29udGVudC5zZXJ2aWNlJztcblxuQENvbXBvbmVudCh7XG4gICAgc2VsZWN0b3I6ICdhZGYtY3JlYXRlLXRhc2stYXR0YWNobWVudCcsXG4gICAgc3R5bGVVcmxzOiBbJy4vY3JlYXRlLXRhc2stYXR0YWNobWVudC5jb21wb25lbnQuc2NzcyddLFxuICAgIHRlbXBsYXRlVXJsOiAnLi9jcmVhdGUtdGFzay1hdHRhY2htZW50LmNvbXBvbmVudC5odG1sJ1xufSlcbmV4cG9ydCBjbGFzcyBBdHRhY2htZW50Q29tcG9uZW50IGltcGxlbWVudHMgT25DaGFuZ2VzIHtcbiAgICAvKiogKHJlcXVpcmVkKSBUaGUgbnVtZXJpYyBJRCBvZiB0aGUgdGFzayB0byBkaXNwbGF5LiAqL1xuICAgIEBJbnB1dCgpXG4gICAgdGFza0lkOiBzdHJpbmc7XG5cbiAgICAvKipcbiAgICAgKiBFbWl0dGVkIHdoZW4gYW4gZXJyb3Igb2NjdXJzIHdoaWxlIGNyZWF0aW5nIG9yIHVwbG9hZGluZyBhblxuICAgICAqICBhdHRhY2htZW50IGZyb20gdGhlIHVzZXIgd2l0aGluIHRoZSBjb21wb25lbnQuXG4gICAgICovXG4gICAgQE91dHB1dCgpXG4gICAgZXJyb3IgPSBuZXcgRXZlbnRFbWl0dGVyPGFueT4oKTtcblxuICAgIC8qKlxuICAgICAqIEVtaXR0ZWQgd2hlbiBhbiBhdHRhY2htZW50IGlzIGNyZWF0ZWQgb3IgdXBsb2FkZWQgc3VjY2Vzc2Z1bGx5XG4gICAgICogZnJvbSB3aXRoaW4gdGhlIGNvbXBvbmVudC5cbiAgICAgKi9cbiAgICBAT3V0cHV0KClcbiAgICBzdWNjZXNzID0gbmV3IEV2ZW50RW1pdHRlcjxhbnk+KCk7XG5cbiAgICBjb25zdHJ1Y3Rvcihwcml2YXRlIHByb2Nlc3NDb250ZW50U2VydmljZTogUHJvY2Vzc0NvbnRlbnRTZXJ2aWNlKSB7fVxuXG4gICAgbmdPbkNoYW5nZXMoY2hhbmdlczogU2ltcGxlQ2hhbmdlcykge1xuICAgICAgICBpZiAoY2hhbmdlc1sndGFza0lkJ10/LmN1cnJlbnRWYWx1ZSkge1xuICAgICAgICAgICAgdGhpcy50YXNrSWQgPSBjaGFuZ2VzWyd0YXNrSWQnXS5jdXJyZW50VmFsdWU7XG4gICAgICAgIH1cbiAgICB9XG5cbiAgICBvbkZpbGVVcGxvYWQoZXZlbnQ6IGFueSkge1xuICAgICAgICBjb25zdCBmaWxlc0xpc3Q6IEZpbGVbXSA9IGV2ZW50LmRldGFpbC5maWxlcy5tYXAoKG9iaikgPT4gb2JqLmZpbGUpO1xuXG4gICAgICAgIGZvciAoY29uc3QgZmlsZUluZm9PYmogb2YgZmlsZXNMaXN0KSB7XG4gICAgICAgICAgICBjb25zdCBmaWxlOiBGaWxlID0gZmlsZUluZm9PYmo7XG4gICAgICAgICAgICBjb25zdCBvcHRzID0ge1xuICAgICAgICAgICAgICAgIGlzUmVsYXRlZENvbnRlbnQ6IHRydWVcbiAgICAgICAgICAgIH07XG4gICAgICAgICAgICB0aGlzLnByb2Nlc3NDb250ZW50U2VydmljZS5jcmVhdGVUYXNrUmVsYXRlZENvbnRlbnQodGhpcy50YXNrSWQsIGZpbGUsIG9wdHMpLnN1YnNjcmliZShcbiAgICAgICAgICAgICAgICAocmVzKSA9PiB7XG4gICAgICAgICAgICAgICAgICAgIHRoaXMuc3VjY2Vzcy5lbWl0KHJlcyk7XG4gICAgICAgICAgICAgICAgfSxcbiAgICAgICAgICAgICAgICAoZXJyKSA9PiB7XG4gICAgICAgICAgICAgICAgICAgIHRoaXMuZXJyb3IuZW1pdChlcnIpO1xuICAgICAgICAgICAgICAgIH1cbiAgICAgICAgICAgICk7XG4gICAgICAgIH1cbiAgICB9XG59XG4iLCI8YnV0dG9uXG4gICAgY29sb3I9XCJwcmltYXJ5XCJcbiAgICBtYXQtYnV0dG9uXG4gICAgbWF0LXJhaXNlZC1idXR0b25cbiAgICBtYXQtaWNvbi1idXR0b25cbiAgICBjbGFzcz1cImFkZi1jcmVhdGUtYXR0YWNobWVudFwiXG4gICAgW2FkZi11cGxvYWRdPVwidHJ1ZVwiXG4gICAgW21vZGVdPVwiWydjbGljayddXCJcbiAgICBbbXVsdGlwbGVdPVwidHJ1ZVwiXG4gICAgKHVwbG9hZC1maWxlcyk9XCJvbkZpbGVVcGxvYWQoJGV2ZW50KVwiPlxuICAgIDxtYXQtaWNvbj5hZGQ8L21hdC1pY29uPlxuPC9idXR0b24+XG4iXX0=