@alfresco/adf-process-services-cloud 8.1.0-16120632321 → 8.1.0-16121703802

package/esm2022/lib/process/start-process/models/process-instance-cloud.model.mjs

@@ -0,0 +1,18 @@
+/*!
+ * @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.
+ */
+export {};
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/process/start-process/models/process-payload-cloud.model.mjs

@@ -0,0 +1,26 @@
+/*!
+ * @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.
+ */
+export class ProcessPayloadCloud {
+    constructor(obj) {
+        this.payloadType = 'StartProcessPayload';
+        this.processDefinitionKey = obj?.processDefinitionKey;
+        this.name = obj?.name;
+        this.businessKey = obj?.businessKey;
+        this.variables = obj?.variables || {};
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/process/start-process/models/process-with-form-payload-cloud.model.mjs

@@ -0,0 +1,26 @@
+/*!
+ * @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.
+ */
+export class ProcessWithFormPayloadCloud {
+    constructor(obj) {
+        this.processName = obj.processName;
+        this.processDefinitionKey = obj.processDefinitionKey;
+        this.variables = obj.variables;
+        this.values = obj.values;
+        this.outcome = obj.outcome;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/process/start-process/public-api.mjs

@@ -0,0 +1,21 @@
+/*!
+ * @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.
+ */
+export * from './components/start-process-cloud.component';
+export * from './models/process-instance-cloud.model';
+export * from './models/process-payload-cloud.model';
+export * from './services/start-process-cloud.service';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHVibGljLWFwaS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uLy4uL2xpYi9wcm9jZXNzLXNlcnZpY2VzLWNsb3VkL3NyYy9saWIvcHJvY2Vzcy9zdGFydC1wcm9jZXNzL3B1YmxpYy1hcGkudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7Ozs7Ozs7Ozs7Ozs7OztHQWVHO0FBRUgsY0FBYyw0Q0FBNEMsQ0FBQztBQUMzRCxjQUFjLHVDQUF1QyxDQUFDO0FBQ3RELGNBQWMsc0NBQXNDLENBQUM7QUFDckQsY0FBYyx3Q0FBd0MsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbIi8qIVxuICogQGxpY2Vuc2VcbiAqIENvcHlyaWdodCDCqSAyMDA1LTIwMjUgSHlsYW5kIFNvZnR3YXJlLCBJbmMuIGFuZCBpdHMgYWZmaWxpYXRlcy4gQWxsIHJpZ2h0cyByZXNlcnZlZC5cbiAqXG4gKiBMaWNlbnNlZCB1bmRlciB0aGUgQXBhY2hlIExpY2Vuc2UsIFZlcnNpb24gMi4wICh0aGUgXCJMaWNlbnNlXCIpO1xuICogeW91IG1heSBub3QgdXNlIHRoaXMgZmlsZSBleGNlcHQgaW4gY29tcGxpYW5jZSB3aXRoIHRoZSBMaWNlbnNlLlxuICogWW91IG1heSBvYnRhaW4gYSBjb3B5IG9mIHRoZSBMaWNlbnNlIGF0XG4gKlxuICogICAgIGh0dHA6Ly93d3cuYXBhY2hlLm9yZy9saWNlbnNlcy9MSUNFTlNFLTIuMFxuICpcbiAqIFVubGVzcyByZXF1aXJlZCBieSBhcHBsaWNhYmxlIGxhdyBvciBhZ3JlZWQgdG8gaW4gd3JpdGluZywgc29mdHdhcmVcbiAqIGRpc3RyaWJ1dGVkIHVuZGVyIHRoZSBMaWNlbnNlIGlzIGRpc3RyaWJ1dGVkIG9uIGFuIFwiQVMgSVNcIiBCQVNJUyxcbiAqIFdJVEhPVVQgV0FSUkFOVElFUyBPUiBDT05ESVRJT05TIE9GIEFOWSBLSU5ELCBlaXRoZXIgZXhwcmVzcyBvciBpbXBsaWVkLlxuICogU2VlIHRoZSBMaWNlbnNlIGZvciB0aGUgc3BlY2lmaWMgbGFuZ3VhZ2UgZ292ZXJuaW5nIHBlcm1pc3Npb25zIGFuZFxuICogbGltaXRhdGlvbnMgdW5kZXIgdGhlIExpY2Vuc2UuXG4gKi9cblxuZXhwb3J0ICogZnJvbSAnLi9jb21wb25lbnRzL3N0YXJ0LXByb2Nlc3MtY2xvdWQuY29tcG9uZW50JztcbmV4cG9ydCAqIGZyb20gJy4vbW9kZWxzL3Byb2Nlc3MtaW5zdGFuY2UtY2xvdWQubW9kZWwnO1xuZXhwb3J0ICogZnJvbSAnLi9tb2RlbHMvcHJvY2Vzcy1wYXlsb2FkLWNsb3VkLm1vZGVsJztcbmV4cG9ydCAqIGZyb20gJy4vc2VydmljZXMvc3RhcnQtcHJvY2Vzcy1jbG91ZC5zZXJ2aWNlJztcbiJdfQ==

package/esm2022/lib/process/start-process/services/start-process-cloud.service.mjs

@@ -0,0 +1,125 @@
+/*!
+ * @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.
+ */
+import { Injectable } from '@angular/core';
+import { throwError } from 'rxjs';
+import { map } from 'rxjs/operators';
+import { ProcessDefinitionCloud } from '../../../models/process-definition-cloud.model';
+import { BaseCloudService } from '../../../services/base-cloud.service';
+import { TaskVariableCloud } from '../../../form/models/task-variable-cloud.model';
+import * as i0 from "@angular/core";
+export class StartProcessCloudService extends BaseCloudService {
+    /**
+     * Gets the process definitions associated with an app.
+     *
+     * @param appName Name of the target app
+     * @param queryParams optional query parameters
+     * @returns Array of process definitions
+     */
+    getProcessDefinitions(appName, queryParams) {
+        if (appName || appName === '') {
+            const url = `${this.getBasePath(appName)}/rb/v1/process-definitions`;
+            return this.get(url, queryParams).pipe(map((res) => res.list.entries.map((processDefs) => new ProcessDefinitionCloud(processDefs.entry))));
+        }
+        else {
+            return throwError('AppName not configured');
+        }
+    }
+    /**
+     * Starts a process based on a process definition, name, form values or variables.
+     *
+     * @param appName name of the Application
+     * @param payload Details of the process (definition key, name, variables, etc)
+     * @returns Details of the process instance just started
+     */
+    startProcess(appName, payload) {
+        const url = `${this.getBasePath(appName)}/rb/v1/process-instances`;
+        payload.payloadType = 'StartProcessPayload';
+        return this.post(url, payload).pipe(map((result) => result.entry));
+    }
+    startProcessWithForm(appName, formId, version, payload) {
+        const url = `${this.getBasePath(appName)}/form/v1/forms/${formId}/submit/versions/${version}`;
+        payload.payloadType = 'StartProcessPayload';
+        return this.post(url, payload);
+    }
+    /**
+     * Update an existing process instance
+     *
+     * @param appName name of the Application
+     * @param processInstanceId process instance to update
+     * @param payload Details of the process (definition key, name, variables, etc)
+     * @returns Details of the process instance just started
+     */
+    updateProcess(appName, processInstanceId, payload) {
+        const url = `${this.getBasePath(appName)}/rb/v1/process-instances/${processInstanceId}`;
+        payload.payloadType = 'UpdateProcessPayload';
+        return this.put(url, payload).pipe(map((processInstance) => processInstance.entry));
+    }
+    /**
+     * Delete an existing process instance
+     *
+     * @param appName Application name
+     * @param processInstanceId the identifier of the process instance to update
+     * @returns Observable<void>
+     */
+    deleteProcess(appName, processInstanceId) {
+        const url = `${this.getBasePath(appName)}/rb/v1/process-instances/${processInstanceId}`;
+        return this.delete(url);
+    }
+    /**
+     * Gets the static values mapped to the start form of a process definition.
+     *
+     * @param appName Name of the app
+     * @param processDefinitionId ID of the target process definition
+     * @returns Static mappings for the start event
+     */
+    getStartEventFormStaticValuesMapping(appName, processDefinitionId) {
+        const apiUrl = `${this.getBasePath(appName)}/rb/v1/process-definitions/${processDefinitionId}/static-values`;
+        return this.get(apiUrl).pipe(map((res) => {
+            const result = [];
+            if (res) {
+                Object.keys(res).forEach((mapping) => result.push(new TaskVariableCloud({ name: mapping, value: res[mapping] })));
+            }
+            return result;
+        }));
+    }
+    /**
+     * Gets the constants mapped to the start form of a process definition.
+     *
+     * @param appName Name of the app
+     * @param processDefinitionId ID of the target process definition
+     * @returns Constants values for the start event
+     */
+    getStartEventConstants(appName, processDefinitionId) {
+        const apiUrl = `${this.getBasePath(appName)}/rb/v1/process-definitions/${processDefinitionId}/constant-values`;
+        return this.get(apiUrl).pipe(map((res) => {
+            const result = [];
+            if (res) {
+                Object.keys(res).forEach((constant) => result.push(new TaskVariableCloud({ name: constant, value: res[constant], type: 'string' })));
+            }
+            return result;
+        }));
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: StartProcessCloudService, deps: null, target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: StartProcessCloudService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: StartProcessCloudService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"start-process-cloud.service.js","sourceRoot":"","sources":["../../../../../../../../lib/process-services-cloud/src/lib/process/start-process/services/start-process-cloud.service.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\nimport { Injectable } from '@angular/core';\nimport { Observable, throwError } from 'rxjs';\nimport { map } from 'rxjs/operators';\nimport { ProcessInstanceCloud } from '../models/process-instance-cloud.model';\nimport { ProcessPayloadCloud } from '../models/process-payload-cloud.model';\nimport { ProcessDefinitionCloud } from '../../../models/process-definition-cloud.model';\nimport { BaseCloudService } from '../../../services/base-cloud.service';\nimport { TaskVariableCloud } from '../../../form/models/task-variable-cloud.model';\n\nexport interface QueryParams {\n    include: 'variables';\n}\n\n@Injectable({\n    providedIn: 'root'\n})\nexport class StartProcessCloudService extends BaseCloudService {\n    /**\n     * Gets the process definitions associated with an app.\n     *\n     * @param appName Name of the target app\n     * @param queryParams optional query parameters\n     * @returns Array of process definitions\n     */\n    getProcessDefinitions(appName: string, queryParams?: QueryParams): Observable<ProcessDefinitionCloud[]> {\n        if (appName || appName === '') {\n            const url = `${this.getBasePath(appName)}/rb/v1/process-definitions`;\n\n            return this.get(url, queryParams).pipe(\n                map((res: any) => res.list.entries.map((processDefs) => new ProcessDefinitionCloud(processDefs.entry)))\n            );\n        } else {\n            return throwError('AppName not configured');\n        }\n    }\n\n    /**\n     * Starts a process based on a process definition, name, form values or variables.\n     *\n     * @param appName name of the Application\n     * @param payload Details of the process (definition key, name, variables, etc)\n     * @returns Details of the process instance just started\n     */\n    startProcess(appName: string, payload: ProcessPayloadCloud): Observable<ProcessInstanceCloud> {\n        const url = `${this.getBasePath(appName)}/rb/v1/process-instances`;\n        payload.payloadType = 'StartProcessPayload';\n\n        return this.post(url, payload).pipe(map((result: any) => result.entry));\n    }\n\n    startProcessWithForm(appName: string, formId: string, version: number, payload: any): Observable<ProcessInstanceCloud> {\n        const url = `${this.getBasePath(appName)}/form/v1/forms/${formId}/submit/versions/${version}`;\n        payload.payloadType = 'StartProcessPayload';\n\n        return this.post(url, payload);\n    }\n\n    /**\n     * Update an existing process instance\n     *\n     * @param appName name of the Application\n     * @param processInstanceId process instance to update\n     * @param payload Details of the process (definition key, name, variables, etc)\n     * @returns Details of the process instance just started\n     */\n    updateProcess(appName: string, processInstanceId: string, payload: ProcessPayloadCloud): Observable<ProcessInstanceCloud> {\n        const url = `${this.getBasePath(appName)}/rb/v1/process-instances/${processInstanceId}`;\n        payload.payloadType = 'UpdateProcessPayload';\n\n        return this.put(url, payload).pipe(map((processInstance: any) => processInstance.entry));\n    }\n\n    /**\n     * Delete an existing process instance\n     *\n     * @param appName Application name\n     * @param processInstanceId the identifier of the process instance to update\n     * @returns Observable<void>\n     */\n    deleteProcess(appName: string, processInstanceId: string): Observable<void> {\n        const url = `${this.getBasePath(appName)}/rb/v1/process-instances/${processInstanceId}`;\n\n        return this.delete(url);\n    }\n\n    /**\n     * Gets the static values mapped to the start form of a process definition.\n     *\n     * @param appName Name of the app\n     * @param processDefinitionId ID of the target process definition\n     * @returns Static mappings for the start event\n     */\n    getStartEventFormStaticValuesMapping(appName: string, processDefinitionId: string): Observable<TaskVariableCloud[]> {\n        const apiUrl = `${this.getBasePath(appName)}/rb/v1/process-definitions/${processDefinitionId}/static-values`;\n        return this.get(apiUrl).pipe(\n            map((res: { [key: string]: any }) => {\n                const result = [];\n                if (res) {\n                    Object.keys(res).forEach((mapping) => result.push(new TaskVariableCloud({ name: mapping, value: res[mapping] })));\n                }\n                return result;\n            })\n        );\n    }\n\n    /**\n     * Gets the constants mapped to the start form of a process definition.\n     *\n     * @param appName Name of the app\n     * @param processDefinitionId ID of the target process definition\n     * @returns Constants values for the start event\n     */\n    getStartEventConstants(appName: string, processDefinitionId: string): Observable<TaskVariableCloud[]> {\n        const apiUrl = `${this.getBasePath(appName)}/rb/v1/process-definitions/${processDefinitionId}/constant-values`;\n        return this.get(apiUrl).pipe(\n            map((res: { [key: string]: any }) => {\n                const result = [];\n                if (res) {\n                    Object.keys(res).forEach((constant) =>\n                        result.push(new TaskVariableCloud({ name: constant, value: res[constant], type: 'string' }))\n                    );\n                }\n                return result;\n            })\n        );\n    }\n}\n"]}

package/esm2022/lib/process-services-cloud.module.mjs

@@ -0,0 +1,91 @@
+/*!
+ * @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.
+ */
+import { NgModule } from '@angular/core';
+import { FormRenderingService, provideTranslations } from '@alfresco/adf-core';
+import { APP_LIST_CLOUD_DIRECTIVES } from './app/app-list-cloud.module';
+import { TaskCloudModule } from './task/task-cloud.module';
+import { ProcessCloudModule } from './process/process-cloud.module';
+import { FORM_CLOUD_DIRECTIVES } from './form/form-cloud.module';
+import { TASK_FORM_CLOUD_DIRECTIVES } from './task/task-form/task-form.module';
+import { LocalPreferenceCloudService, PROCESS_FILTERS_SERVICE_TOKEN, TASK_FILTERS_SERVICE_TOKEN, PROCESS_LISTS_PREFERENCES_SERVICE_TOKEN, TASK_LIST_PREFERENCES_SERVICE_TOKEN } from './services/public-api';
+import { CloudFormRenderingService } from './form/components/cloud-form-rendering.service';
+import { RichTextEditorComponent } from './rich-text-editor';
+import { GroupCloudComponent } from './group/components/group-cloud.component';
+import { PeopleCloudComponent } from './people/components/people-cloud.component';
+import * as i0 from "@angular/core";
+import * as i1 from "./app/components/app-list-cloud/app-list-cloud.component";
+import * as i2 from "./app/components/app-details-cloud/app-details-cloud.component";
+import * as i3 from "./rich-text-editor/rich-text-editor.component";
+import * as i4 from "./form/components/spinner/form-spinner.component";
+import * as i5 from "./form/components/widgets/properties-viewer/properties-viewer-wrapper/properties-viewer-wrapper.component";
+import * as i6 from "./form/components/widgets/properties-viewer/properties-viewer.widget";
+import * as i7 from "./form/components/widgets/display-rich-text/display-rich-text.widget";
+import * as i8 from "./form/components/widgets/file-viewer/file-viewer.widget";
+import * as i9 from "./form/components/widgets/attach-file/file-properties-table/file-properties-table-cloud.component";
+import * as i10 from "./form/components/form-cloud-custom-outcomes.component";
+import * as i11 from "./form/components/form-definition-selector-cloud.component";
+import * as i12 from "./form/components/widgets/radio-buttons/radio-buttons-cloud.widget";
+import * as i13 from "./form/components/widgets/attach-file/attach-file-cloud-widget.component";
+import * as i14 from "./form/components/widgets/upload/upload-cloud.widget";
+import * as i15 from "./form/components/widgets/people/people-cloud.widget";
+import * as i16 from "./form/components/widgets/group/group-cloud.widget";
+import * as i17 from "./form/components/form-cloud.component";
+import * as i18 from "./task/task-form/components/user-task-cloud-buttons/user-task-cloud-buttons.component";
+import * as i19 from "./task/task-form/components/task-form-cloud/task-form-cloud.component";
+import * as i20 from "./task/task-form/components/user-task-cloud/user-task-cloud.component";
+export const PROCESS_SERVICES_CLOUD_DIRECTIVES = [
+    ...APP_LIST_CLOUD_DIRECTIVES,
+    ...FORM_CLOUD_DIRECTIVES,
+    ...TASK_FORM_CLOUD_DIRECTIVES,
+    PeopleCloudComponent,
+    RichTextEditorComponent
+];
+export class ProcessServicesCloudModule {
+    static forRoot(filterPreferenceServiceInstance, listPreferenceServiceInstance) {
+        return {
+            ngModule: ProcessServicesCloudModule,
+            providers: [
+                provideTranslations('adf-process-services-cloud', 'assets/adf-process-services-cloud'),
+                { provide: PROCESS_FILTERS_SERVICE_TOKEN, useExisting: filterPreferenceServiceInstance ?? LocalPreferenceCloudService },
+                { provide: TASK_FILTERS_SERVICE_TOKEN, useExisting: filterPreferenceServiceInstance ?? LocalPreferenceCloudService },
+                { provide: PROCESS_LISTS_PREFERENCES_SERVICE_TOKEN, useExisting: listPreferenceServiceInstance ?? LocalPreferenceCloudService },
+                { provide: TASK_LIST_PREFERENCES_SERVICE_TOKEN, useExisting: listPreferenceServiceInstance ?? LocalPreferenceCloudService },
+                FormRenderingService,
+                { provide: FormRenderingService, useClass: CloudFormRenderingService }
+            ]
+        };
+    }
+    static forChild() {
+        return {
+            ngModule: ProcessServicesCloudModule
+        };
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: ProcessServicesCloudModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule }); }
+    static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "18.2.13", ngImport: i0, type: ProcessServicesCloudModule, imports: [ProcessCloudModule, TaskCloudModule, GroupCloudComponent, i1.AppListCloudComponent, i2.AppDetailsCloudComponent, i3.RichTextEditorComponent, i4.FormSpinnerComponent, i5.PropertiesViewerWrapperComponent, i6.PropertiesViewerWidgetComponent, i7.DisplayRichTextWidgetComponent, i8.FileViewerWidgetComponent, i9.FilePropertiesTableCloudComponent, i10.FormCustomOutcomesComponent, i11.FormDefinitionSelectorCloudComponent, i12.RadioButtonsCloudWidgetComponent, i13.AttachFileCloudWidgetComponent, i14.UploadCloudWidgetComponent, i15.PeopleCloudWidgetComponent, i16.GroupCloudWidgetComponent, i17.FormCloudComponent, i18.UserTaskCloudButtonsComponent, i19.TaskFormCloudComponent, i20.UserTaskCloudComponent, PeopleCloudComponent,
+            RichTextEditorComponent], exports: [ProcessCloudModule, TaskCloudModule, GroupCloudComponent, i1.AppListCloudComponent, i2.AppDetailsCloudComponent, i3.RichTextEditorComponent, i4.FormSpinnerComponent, i5.PropertiesViewerWrapperComponent, i6.PropertiesViewerWidgetComponent, i7.DisplayRichTextWidgetComponent, i8.FileViewerWidgetComponent, i9.FilePropertiesTableCloudComponent, i10.FormCustomOutcomesComponent, i11.FormDefinitionSelectorCloudComponent, i12.RadioButtonsCloudWidgetComponent, i13.AttachFileCloudWidgetComponent, i14.UploadCloudWidgetComponent, i15.PeopleCloudWidgetComponent, i16.GroupCloudWidgetComponent, i17.FormCloudComponent, i18.UserTaskCloudButtonsComponent, i19.TaskFormCloudComponent, i20.UserTaskCloudComponent, PeopleCloudComponent,
+            RichTextEditorComponent] }); }
+    static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: ProcessServicesCloudModule, providers: [provideTranslations('adf-process-services-cloud', 'assets/adf-process-services-cloud')], imports: [ProcessCloudModule, TaskCloudModule, GroupCloudComponent, i1.AppListCloudComponent, i2.AppDetailsCloudComponent, i4.FormSpinnerComponent, i5.PropertiesViewerWrapperComponent, i6.PropertiesViewerWidgetComponent, i8.FileViewerWidgetComponent, i9.FilePropertiesTableCloudComponent, i11.FormDefinitionSelectorCloudComponent, i12.RadioButtonsCloudWidgetComponent, i13.AttachFileCloudWidgetComponent, i14.UploadCloudWidgetComponent, i15.PeopleCloudWidgetComponent, i16.GroupCloudWidgetComponent, i17.FormCloudComponent, i18.UserTaskCloudButtonsComponent, i19.TaskFormCloudComponent, i20.UserTaskCloudComponent, PeopleCloudComponent, ProcessCloudModule, TaskCloudModule] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: ProcessServicesCloudModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    imports: [ProcessCloudModule, TaskCloudModule, GroupCloudComponent, ...PROCESS_SERVICES_CLOUD_DIRECTIVES],
+                    providers: [provideTranslations('adf-process-services-cloud', 'assets/adf-process-services-cloud')],
+                    exports: [ProcessCloudModule, TaskCloudModule, GroupCloudComponent, ...PROCESS_SERVICES_CLOUD_DIRECTIVES]
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/rich-text-editor/editorjs-config.mjs

@@ -0,0 +1,101 @@
+/*!
+ * @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.
+ */
+/** Plugin import */
+import CodeTool from '@editorjs/code';
+import Header from '@editorjs/header';
+import Paragraph from '@editorjs/paragraph';
+import InlineCode from '@editorjs/inline-code';
+import List from '@editorjs/list';
+import Marker from '@editorjs/marker';
+import Underline from '@editorjs/underline';
+import ChangeFontSize from '@valano/change-font-size';
+import ColorPlugin from 'editorjs-text-color-plugin';
+import AlignmentTuneTool from 'editorjs-text-alignment-blocktune';
+export const editorJsConfig = {
+    autofocus: true,
+    logLevel: 'ERROR',
+    tools: {
+        underline: {
+            class: Underline,
+            shortcut: 'CMD+U'
+        },
+        header: {
+            class: Header,
+            inlineToolbar: true,
+            tunes: ['anyTuneName']
+        },
+        paragraph: {
+            class: Paragraph,
+            inlineToolbar: true,
+            tunes: ['anyTuneName']
+        },
+        list: {
+            class: List,
+            inlineToolbar: true,
+            config: {
+                defaultStyle: 'unordered'
+            }
+        },
+        Color: {
+            class: ColorPlugin,
+            config: {
+                customPicker: true,
+                colorCollections: [
+                    '#FF1300',
+                    '#ffa500',
+                    '#9C27B0',
+                    '#673AB7',
+                    '#3F51B5',
+                    '#0070FF',
+                    '#03A9F4',
+                    '#00BCD4',
+                    '#5f9ea0',
+                    '#4CAF50',
+                    '#8BC34A',
+                    '#CDDC39',
+                    '#FFF',
+                    '#000',
+                    '#c0c0c0',
+                    '#808080',
+                    '#800000'
+                ],
+                defaultColor: '#FF1300',
+                type: 'text'
+            }
+        },
+        Marker: {
+            class: Marker,
+            shortcut: 'CMD+M'
+        },
+        'Increase/Decrease font size': {
+            class: ChangeFontSize,
+            config: {
+                cssClass: 'plus20pc',
+                buttonIcon: '<span class="material-icons">format_size</span>'
+            }
+        },
+        inlineCode: {
+            class: InlineCode,
+            shortcut: 'CMD+SHIFT+M'
+        },
+        anyTuneName: {
+            class: AlignmentTuneTool
+        },
+        code: CodeTool
+    }
+};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZWRpdG9yanMtY29uZmlnLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vbGliL3Byb2Nlc3Mtc2VydmljZXMtY2xvdWQvc3JjL2xpYi9yaWNoLXRleHQtZWRpdG9yL2VkaXRvcmpzLWNvbmZpZy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQTs7Ozs7Ozs7Ozs7Ozs7O0dBZUc7QUFFSCxvQkFBb0I7QUFDcEIsT0FBTyxRQUFRLE1BQU0sZ0JBQWdCLENBQUM7QUFDdEMsT0FBTyxNQUFNLE1BQU0sa0JBQWtCLENBQUM7QUFDdEMsT0FBTyxTQUFTLE1BQU0scUJBQXFCLENBQUM7QUFDNUMsT0FBTyxVQUFVLE1BQU0sdUJBQXVCLENBQUM7QUFDL0MsT0FBTyxJQUFJLE1BQU0sZ0JBQWdCLENBQUM7QUFDbEMsT0FBTyxNQUFNLE1BQU0sa0JBQWtCLENBQUM7QUFDdEMsT0FBTyxTQUFTLE1BQU0scUJBQXFCLENBQUM7QUFDNUMsT0FBTyxjQUFjLE1BQU0sMEJBQTBCLENBQUM7QUFDdEQsT0FBTyxXQUFXLE1BQU0sNEJBQTRCLENBQUM7QUFDckQsT0FBTyxpQkFBaUIsTUFBTSxtQ0FBbUMsQ0FBQztBQUVsRSxNQUFNLENBQUMsTUFBTSxjQUFjLEdBQUc7SUFDMUIsU0FBUyxFQUFFLElBQUk7SUFDZixRQUFRLEVBQUUsT0FBTztJQUNqQixLQUFLLEVBQUU7UUFDSCxTQUFTLEVBQUU7WUFDUCxLQUFLLEVBQUUsU0FBUztZQUNoQixRQUFRLEVBQUUsT0FBTztTQUNwQjtRQUNELE1BQU0sRUFBRTtZQUNKLEtBQUssRUFBRSxNQUFNO1lBQ2IsYUFBYSxFQUFFLElBQUk7WUFDbkIsS0FBSyxFQUFFLENBQUMsYUFBYSxDQUFDO1NBQ3pCO1FBQ0QsU0FBUyxFQUFFO1lBQ1AsS0FBSyxFQUFFLFNBQVM7WUFDaEIsYUFBYSxFQUFFLElBQUk7WUFDbkIsS0FBSyxFQUFFLENBQUMsYUFBYSxDQUFDO1NBQ3pCO1FBQ0QsSUFBSSxFQUFFO1lBQ0YsS0FBSyxFQUFFLElBQUk7WUFDWCxhQUFhLEVBQUUsSUFBSTtZQUNuQixNQUFNLEVBQUU7Z0JBQ0osWUFBWSxFQUFFLFdBQVc7YUFDNUI7U0FDSjtRQUNELEtBQUssRUFBRTtZQUNILEtBQUssRUFBRSxXQUFXO1lBQ2xCLE1BQU0sRUFBRTtnQkFDSixZQUFZLEVBQUUsSUFBSTtnQkFDbEIsZ0JBQWdCLEVBQUU7b0JBQ2QsU0FBUztvQkFDVCxTQUFTO29CQUNULFNBQVM7b0JBQ1QsU0FBUztvQkFDVCxTQUFTO29CQUNULFNBQVM7b0JBQ1QsU0FBUztvQkFDVCxTQUFTO29CQUNULFNBQVM7b0JBQ1QsU0FBUztvQkFDVCxTQUFTO29CQUNULFNBQVM7b0JBQ1QsTUFBTTtvQkFDTixNQUFNO29CQUNOLFNBQVM7b0JBQ1QsU0FBUztvQkFDVCxTQUFTO2lCQUNaO2dCQUNELFlBQVksRUFBRSxTQUFTO2dCQUN2QixJQUFJLEVBQUUsTUFBTTthQUNmO1NBQ0o7UUFDRCxNQUFNLEVBQUU7WUFDSixLQUFLLEVBQUUsTUFBTTtZQUNiLFFBQVEsRUFBRSxPQUFPO1NBQ3BCO1FBQ0QsNkJBQTZCLEVBQUU7WUFDM0IsS0FBSyxFQUFFLGNBQWM7WUFDckIsTUFBTSxFQUFFO2dCQUNKLFFBQVEsRUFBRSxVQUFVO2dCQUNwQixVQUFVLEVBQUUsaURBQWlEO2FBQ2hFO1NBQ0o7UUFDRCxVQUFVLEVBQUU7WUFDUixLQUFLLEVBQUUsVUFBVTtZQUNqQixRQUFRLEVBQUUsYUFBYTtTQUMxQjtRQUNELFdBQVcsRUFBRTtZQUNULEtBQUssRUFBRSxpQkFBaUI7U0FDM0I7UUFDRCxJQUFJLEVBQUUsUUFBUTtLQUNqQjtDQUNKLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyIvKiFcbiAqIEBsaWNlbnNlXG4gKiBDb3B5cmlnaHQgwqkgMjAwNS0yMDI1IEh5bGFuZCBTb2Z0d2FyZSwgSW5jLiBhbmQgaXRzIGFmZmlsaWF0ZXMuIEFsbCByaWdodHMgcmVzZXJ2ZWQuXG4gKlxuICogTGljZW5zZWQgdW5kZXIgdGhlIEFwYWNoZSBMaWNlbnNlLCBWZXJzaW9uIDIuMCAodGhlIFwiTGljZW5zZVwiKTtcbiAqIHlvdSBtYXkgbm90IHVzZSB0aGlzIGZpbGUgZXhjZXB0IGluIGNvbXBsaWFuY2Ugd2l0aCB0aGUgTGljZW5zZS5cbiAqIFlvdSBtYXkgb2J0YWluIGEgY29weSBvZiB0aGUgTGljZW5zZSBhdFxuICpcbiAqICAgICBodHRwOi8vd3d3LmFwYWNoZS5vcmcvbGljZW5zZXMvTElDRU5TRS0yLjBcbiAqXG4gKiBVbmxlc3MgcmVxdWlyZWQgYnkgYXBwbGljYWJsZSBsYXcgb3IgYWdyZWVkIHRvIGluIHdyaXRpbmcsIHNvZnR3YXJlXG4gKiBkaXN0cmlidXRlZCB1bmRlciB0aGUgTGljZW5zZSBpcyBkaXN0cmlidXRlZCBvbiBhbiBcIkFTIElTXCIgQkFTSVMsXG4gKiBXSVRIT1VUIFdBUlJBTlRJRVMgT1IgQ09ORElUSU9OUyBPRiBBTlkgS0lORCwgZWl0aGVyIGV4cHJlc3Mgb3IgaW1wbGllZC5cbiAqIFNlZSB0aGUgTGljZW5zZSBmb3IgdGhlIHNwZWNpZmljIGxhbmd1YWdlIGdvdmVybmluZyBwZXJtaXNzaW9ucyBhbmRcbiAqIGxpbWl0YXRpb25zIHVuZGVyIHRoZSBMaWNlbnNlLlxuICovXG5cbi8qKiBQbHVnaW4gaW1wb3J0ICovXG5pbXBvcnQgQ29kZVRvb2wgZnJvbSAnQGVkaXRvcmpzL2NvZGUnO1xuaW1wb3J0IEhlYWRlciBmcm9tICdAZWRpdG9yanMvaGVhZGVyJztcbmltcG9ydCBQYXJhZ3JhcGggZnJvbSAnQGVkaXRvcmpzL3BhcmFncmFwaCc7XG5pbXBvcnQgSW5saW5lQ29kZSBmcm9tICdAZWRpdG9yanMvaW5saW5lLWNvZGUnO1xuaW1wb3J0IExpc3QgZnJvbSAnQGVkaXRvcmpzL2xpc3QnO1xuaW1wb3J0IE1hcmtlciBmcm9tICdAZWRpdG9yanMvbWFya2VyJztcbmltcG9ydCBVbmRlcmxpbmUgZnJvbSAnQGVkaXRvcmpzL3VuZGVybGluZSc7XG5pbXBvcnQgQ2hhbmdlRm9udFNpemUgZnJvbSAnQHZhbGFuby9jaGFuZ2UtZm9udC1zaXplJztcbmltcG9ydCBDb2xvclBsdWdpbiBmcm9tICdlZGl0b3Jqcy10ZXh0LWNvbG9yLXBsdWdpbic7XG5pbXBvcnQgQWxpZ25tZW50VHVuZVRvb2wgZnJvbSAnZWRpdG9yanMtdGV4dC1hbGlnbm1lbnQtYmxvY2t0dW5lJztcblxuZXhwb3J0IGNvbnN0IGVkaXRvckpzQ29uZmlnID0ge1xuICAgIGF1dG9mb2N1czogdHJ1ZSxcbiAgICBsb2dMZXZlbDogJ0VSUk9SJyxcbiAgICB0b29sczoge1xuICAgICAgICB1bmRlcmxpbmU6IHtcbiAgICAgICAgICAgIGNsYXNzOiBVbmRlcmxpbmUsXG4gICAgICAgICAgICBzaG9ydGN1dDogJ0NNRCtVJ1xuICAgICAgICB9LFxuICAgICAgICBoZWFkZXI6IHtcbiAgICAgICAgICAgIGNsYXNzOiBIZWFkZXIsXG4gICAgICAgICAgICBpbmxpbmVUb29sYmFyOiB0cnVlLFxuICAgICAgICAgICAgdHVuZXM6IFsnYW55VHVuZU5hbWUnXVxuICAgICAgICB9LFxuICAgICAgICBwYXJhZ3JhcGg6IHtcbiAgICAgICAgICAgIGNsYXNzOiBQYXJhZ3JhcGgsXG4gICAgICAgICAgICBpbmxpbmVUb29sYmFyOiB0cnVlLFxuICAgICAgICAgICAgdHVuZXM6IFsnYW55VHVuZU5hbWUnXVxuICAgICAgICB9LFxuICAgICAgICBsaXN0OiB7XG4gICAgICAgICAgICBjbGFzczogTGlzdCxcbiAgICAgICAgICAgIGlubGluZVRvb2xiYXI6IHRydWUsXG4gICAgICAgICAgICBjb25maWc6IHtcbiAgICAgICAgICAgICAgICBkZWZhdWx0U3R5bGU6ICd1bm9yZGVyZWQnXG4gICAgICAgICAgICB9XG4gICAgICAgIH0sXG4gICAgICAgIENvbG9yOiB7XG4gICAgICAgICAgICBjbGFzczogQ29sb3JQbHVnaW4sXG4gICAgICAgICAgICBjb25maWc6IHtcbiAgICAgICAgICAgICAgICBjdXN0b21QaWNrZXI6IHRydWUsXG4gICAgICAgICAgICAgICAgY29sb3JDb2xsZWN0aW9uczogW1xuICAgICAgICAgICAgICAgICAgICAnI0ZGMTMwMCcsXG4gICAgICAgICAgICAgICAgICAgICcjZmZhNTAwJyxcbiAgICAgICAgICAgICAgICAgICAgJyM5QzI3QjAnLFxuICAgICAgICAgICAgICAgICAgICAnIzY3M0FCNycsXG4gICAgICAgICAgICAgICAgICAgICcjM0Y1MUI1JyxcbiAgICAgICAgICAgICAgICAgICAgJyMwMDcwRkYnLFxuICAgICAgICAgICAgICAgICAgICAnIzAzQTlGNCcsXG4gICAgICAgICAgICAgICAgICAgICcjMDBCQ0Q0JyxcbiAgICAgICAgICAgICAgICAgICAgJyM1ZjllYTAnLFxuICAgICAgICAgICAgICAgICAgICAnIzRDQUY1MCcsXG4gICAgICAgICAgICAgICAgICAgICcjOEJDMzRBJyxcbiAgICAgICAgICAgICAgICAgICAgJyNDRERDMzknLFxuICAgICAgICAgICAgICAgICAgICAnI0ZGRicsXG4gICAgICAgICAgICAgICAgICAgICcjMDAwJyxcbiAgICAgICAgICAgICAgICAgICAgJyNjMGMwYzAnLFxuICAgICAgICAgICAgICAgICAgICAnIzgwODA4MCcsXG4gICAgICAgICAgICAgICAgICAgICcjODAwMDAwJ1xuICAgICAgICAgICAgICAgIF0sXG4gICAgICAgICAgICAgICAgZGVmYXVsdENvbG9yOiAnI0ZGMTMwMCcsXG4gICAgICAgICAgICAgICAgdHlwZTogJ3RleHQnXG4gICAgICAgICAgICB9XG4gICAgICAgIH0sXG4gICAgICAgIE1hcmtlcjoge1xuICAgICAgICAgICAgY2xhc3M6IE1hcmtlcixcbiAgICAgICAgICAgIHNob3J0Y3V0OiAnQ01EK00nXG4gICAgICAgIH0sXG4gICAgICAgICdJbmNyZWFzZS9EZWNyZWFzZSBmb250IHNpemUnOiB7XG4gICAgICAgICAgICBjbGFzczogQ2hhbmdlRm9udFNpemUsXG4gICAgICAgICAgICBjb25maWc6IHtcbiAgICAgICAgICAgICAgICBjc3NDbGFzczogJ3BsdXMyMHBjJyxcbiAgICAgICAgICAgICAgICBidXR0b25JY29uOiAnPHNwYW4gY2xhc3M9XCJtYXRlcmlhbC1pY29uc1wiPmZvcm1hdF9zaXplPC9zcGFuPidcbiAgICAgICAgICAgIH1cbiAgICAgICAgfSxcbiAgICAgICAgaW5saW5lQ29kZToge1xuICAgICAgICAgICAgY2xhc3M6IElubGluZUNvZGUsXG4gICAgICAgICAgICBzaG9ydGN1dDogJ0NNRCtTSElGVCtNJ1xuICAgICAgICB9LFxuICAgICAgICBhbnlUdW5lTmFtZToge1xuICAgICAgICAgICAgY2xhc3M6IEFsaWdubWVudFR1bmVUb29sXG4gICAgICAgIH0sXG4gICAgICAgIGNvZGU6IENvZGVUb29sXG4gICAgfVxufTtcbiJdfQ==

package/esm2022/lib/rich-text-editor/index.mjs

@@ -0,0 +1,18 @@
+/*!
+ * @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.
+ */
+export * from './public-api';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9saWIvcHJvY2Vzcy1zZXJ2aWNlcy1jbG91ZC9zcmMvbGliL3JpY2gtdGV4dC1lZGl0b3IvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7Ozs7Ozs7Ozs7Ozs7OztHQWVHO0FBRUgsY0FBYyxjQUFjLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyIvKiFcbiAqIEBsaWNlbnNlXG4gKiBDb3B5cmlnaHQgwqkgMjAwNS0yMDI1IEh5bGFuZCBTb2Z0d2FyZSwgSW5jLiBhbmQgaXRzIGFmZmlsaWF0ZXMuIEFsbCByaWdodHMgcmVzZXJ2ZWQuXG4gKlxuICogTGljZW5zZWQgdW5kZXIgdGhlIEFwYWNoZSBMaWNlbnNlLCBWZXJzaW9uIDIuMCAodGhlIFwiTGljZW5zZVwiKTtcbiAqIHlvdSBtYXkgbm90IHVzZSB0aGlzIGZpbGUgZXhjZXB0IGluIGNvbXBsaWFuY2Ugd2l0aCB0aGUgTGljZW5zZS5cbiAqIFlvdSBtYXkgb2J0YWluIGEgY29weSBvZiB0aGUgTGljZW5zZSBhdFxuICpcbiAqICAgICBodHRwOi8vd3d3LmFwYWNoZS5vcmcvbGljZW5zZXMvTElDRU5TRS0yLjBcbiAqXG4gKiBVbmxlc3MgcmVxdWlyZWQgYnkgYXBwbGljYWJsZSBsYXcgb3IgYWdyZWVkIHRvIGluIHdyaXRpbmcsIHNvZnR3YXJlXG4gKiBkaXN0cmlidXRlZCB1bmRlciB0aGUgTGljZW5zZSBpcyBkaXN0cmlidXRlZCBvbiBhbiBcIkFTIElTXCIgQkFTSVMsXG4gKiBXSVRIT1VUIFdBUlJBTlRJRVMgT1IgQ09ORElUSU9OUyBPRiBBTlkgS0lORCwgZWl0aGVyIGV4cHJlc3Mgb3IgaW1wbGllZC5cbiAqIFNlZSB0aGUgTGljZW5zZSBmb3IgdGhlIHNwZWNpZmljIGxhbmd1YWdlIGdvdmVybmluZyBwZXJtaXNzaW9ucyBhbmRcbiAqIGxpbWl0YXRpb25zIHVuZGVyIHRoZSBMaWNlbnNlLlxuICovXG5cbmV4cG9ydCAqIGZyb20gJy4vcHVibGljLWFwaSc7XG4iXX0=

package/esm2022/lib/rich-text-editor/public-api.mjs

@@ -0,0 +1,19 @@
+/*!
+ * @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.
+ */
+export * from './rich-text-editor.component';
+export * from './rich-text-editor.module';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHVibGljLWFwaS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uL2xpYi9wcm9jZXNzLXNlcnZpY2VzLWNsb3VkL3NyYy9saWIvcmljaC10ZXh0LWVkaXRvci9wdWJsaWMtYXBpLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOzs7Ozs7Ozs7Ozs7Ozs7R0FlRztBQUVILGNBQWMsOEJBQThCLENBQUM7QUFDN0MsY0FBYywyQkFBMkIsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbIi8qIVxuICogQGxpY2Vuc2VcbiAqIENvcHlyaWdodCDCqSAyMDA1LTIwMjUgSHlsYW5kIFNvZnR3YXJlLCBJbmMuIGFuZCBpdHMgYWZmaWxpYXRlcy4gQWxsIHJpZ2h0cyByZXNlcnZlZC5cbiAqXG4gKiBMaWNlbnNlZCB1bmRlciB0aGUgQXBhY2hlIExpY2Vuc2UsIFZlcnNpb24gMi4wICh0aGUgXCJMaWNlbnNlXCIpO1xuICogeW91IG1heSBub3QgdXNlIHRoaXMgZmlsZSBleGNlcHQgaW4gY29tcGxpYW5jZSB3aXRoIHRoZSBMaWNlbnNlLlxuICogWW91IG1heSBvYnRhaW4gYSBjb3B5IG9mIHRoZSBMaWNlbnNlIGF0XG4gKlxuICogICAgIGh0dHA6Ly93d3cuYXBhY2hlLm9yZy9saWNlbnNlcy9MSUNFTlNFLTIuMFxuICpcbiAqIFVubGVzcyByZXF1aXJlZCBieSBhcHBsaWNhYmxlIGxhdyBvciBhZ3JlZWQgdG8gaW4gd3JpdGluZywgc29mdHdhcmVcbiAqIGRpc3RyaWJ1dGVkIHVuZGVyIHRoZSBMaWNlbnNlIGlzIGRpc3RyaWJ1dGVkIG9uIGFuIFwiQVMgSVNcIiBCQVNJUyxcbiAqIFdJVEhPVVQgV0FSUkFOVElFUyBPUiBDT05ESVRJT05TIE9GIEFOWSBLSU5ELCBlaXRoZXIgZXhwcmVzcyBvciBpbXBsaWVkLlxuICogU2VlIHRoZSBMaWNlbnNlIGZvciB0aGUgc3BlY2lmaWMgbGFuZ3VhZ2UgZ292ZXJuaW5nIHBlcm1pc3Npb25zIGFuZFxuICogbGltaXRhdGlvbnMgdW5kZXIgdGhlIExpY2Vuc2UuXG4gKi9cblxuZXhwb3J0ICogZnJvbSAnLi9yaWNoLXRleHQtZWRpdG9yLmNvbXBvbmVudCc7XG5leHBvcnQgKiBmcm9tICcuL3JpY2gtdGV4dC1lZGl0b3IubW9kdWxlJztcbiJdfQ==

package/esm2022/lib/rich-text-editor/rich-text-editor.component.mjs

@@ -0,0 +1,80 @@
+/*!
+ * @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.
+ */
+import { Component, Input, ViewEncapsulation } from '@angular/core';
+import EditorJS from '@editorjs/editorjs';
+import { Subject } from 'rxjs';
+import { editorJsConfig } from './editorjs-config';
+import * as i0 from "@angular/core";
+export class RichTextEditorComponent {
+    constructor() {
+        this.placeholder = '';
+        this.autoFocus = false;
+        this._outputData = new Subject();
+        this.outputData$ = this._outputData.asObservable();
+        this.isReady = false;
+    }
+    ngOnInit() {
+        this.dynamicId = `editorjs-${crypto.getRandomValues(new Uint32Array(1))}`;
+    }
+    ngAfterViewInit() {
+        this.editorInstance = new EditorJS({
+            holder: this.dynamicId,
+            placeholder: this.placeholder,
+            autofocus: this.autoFocus,
+            ...editorJsConfig,
+            data: this.data,
+            onChange: () => {
+                this.sendEditorOutputData();
+            },
+            onReady: () => {
+                this.isReady = true;
+                this.sendEditorOutputData();
+            }
+        });
+    }
+    sendEditorOutputData() {
+        this.editorInstance
+            .save()
+            .then((outputData) => {
+            this._outputData.next(outputData);
+        })
+            .catch((error) => {
+            console.error('Saving failed: ', error);
+        });
+    }
+    getEditorContent() {
+        return this.editorInstance.save();
+    }
+    ngOnDestroy() {
+        if (this.isReady) {
+            this.editorInstance.destroy();
+        }
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: RichTextEditorComponent, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "18.2.13", type: RichTextEditorComponent, isStandalone: true, selector: "adf-cloud-rich-text-editor", inputs: { data: "data", placeholder: "placeholder", autoFocus: "autoFocus" }, ngImport: i0, template: "<div class=\"adf-rich-text-editor-container\">\n    <div class=\"editorjs\" id=\"{{dynamicId}}\"></div>\n</div>\n", styles: [".adf-rich-text-editor-container{color:var(--theme-text-fg-color, rgba(0, 0, 0, .87))}.adf-rich-text-editor-container .editorjs.readonly .codex-editor__redactor{padding-bottom:0!important}.adf-rich-text-editor-container .ce-inline-toolbar{transform:scale(1)}.adf-rich-text-editor-container .ce-inline-toolbar .ce-popover__items{overflow:hidden}.adf-rich-text-editor-container .ce-inline-toolbar .ce-inline-tool .material-icons{font-size:20px}xy-color-picker{position:relative;background-color:transparent;margin:0;overflow:hidden}\n"], encapsulation: i0.ViewEncapsulation.None }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: RichTextEditorComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'adf-cloud-rich-text-editor', standalone: true, encapsulation: ViewEncapsulation.None, template: "<div class=\"adf-rich-text-editor-container\">\n    <div class=\"editorjs\" id=\"{{dynamicId}}\"></div>\n</div>\n", styles: [".adf-rich-text-editor-container{color:var(--theme-text-fg-color, rgba(0, 0, 0, .87))}.adf-rich-text-editor-container .editorjs.readonly .codex-editor__redactor{padding-bottom:0!important}.adf-rich-text-editor-container .ce-inline-toolbar{transform:scale(1)}.adf-rich-text-editor-container .ce-inline-toolbar .ce-popover__items{overflow:hidden}.adf-rich-text-editor-container .ce-inline-toolbar .ce-inline-tool .material-icons{font-size:20px}xy-color-picker{position:relative;background-color:transparent;margin:0;overflow:hidden}\n"] }]
+        }], propDecorators: { data: [{
+                type: Input
+            }], placeholder: [{
+                type: Input
+            }], autoFocus: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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