@alfresco/adf-core 8.1.0-14489297497 → 8.1.0-14491540427

package/esm2022/lib/form/components/widgets/core/form-outcome.model.mjs

@@ -0,0 +1,38 @@
+/*!
+ * @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 { FormWidgetModel } from './form-widget.model';
+import { WidgetVisibilityModel } from '../../../models/widget-visibility.model';
+export class FormOutcomeModel extends FormWidgetModel {
+    static { this.SAVE_ACTION = 'SAVE'; } // Activiti 'Save' action name
+    static { this.COMPLETE_ACTION = 'COMPLETE'; } // Activiti 'Complete' action name
+    static { this.START_PROCESS_ACTION = 'START PROCESS'; } // Activiti 'Start Process' action name
+    constructor(form, json) {
+        super(form, json);
+        this.isSystem = false;
+        this.isSelected = false;
+        this.isVisible = true;
+        this.skipValidation = false;
+        if (json) {
+            this.isSystem = json.isSystem ? true : false;
+            this.skipValidation = json.skipValidation ?? false;
+            this.isSelected = form && json.name === form.selectedOutcome ? true : false;
+            this.visibilityCondition = new WidgetVisibilityModel(json.visibilityCondition);
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/form/components/widgets/core/form-values.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,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZm9ybS12YWx1ZXMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi9saWIvY29yZS9zcmMvbGliL2Zvcm0vY29tcG9uZW50cy93aWRnZXRzL2NvcmUvZm9ybS12YWx1ZXMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7Ozs7Ozs7Ozs7Ozs7OztHQWVHIiwic291cmNlc0NvbnRlbnQiOlsiLyohXG4gKiBAbGljZW5zZVxuICogQ29weXJpZ2h0IMKpIDIwMDUtMjAyNSBIeWxhbmQgU29mdHdhcmUsIEluYy4gYW5kIGl0cyBhZmZpbGlhdGVzLiBBbGwgcmlnaHRzIHJlc2VydmVkLlxuICpcbiAqIExpY2Vuc2VkIHVuZGVyIHRoZSBBcGFjaGUgTGljZW5zZSwgVmVyc2lvbiAyLjAgKHRoZSBcIkxpY2Vuc2VcIik7XG4gKiB5b3UgbWF5IG5vdCB1c2UgdGhpcyBmaWxlIGV4Y2VwdCBpbiBjb21wbGlhbmNlIHdpdGggdGhlIExpY2Vuc2UuXG4gKiBZb3UgbWF5IG9idGFpbiBhIGNvcHkgb2YgdGhlIExpY2Vuc2UgYXRcbiAqXG4gKiAgICAgaHR0cDovL3d3dy5hcGFjaGUub3JnL2xpY2Vuc2VzL0xJQ0VOU0UtMi4wXG4gKlxuICogVW5sZXNzIHJlcXVpcmVkIGJ5IGFwcGxpY2FibGUgbGF3IG9yIGFncmVlZCB0byBpbiB3cml0aW5nLCBzb2Z0d2FyZVxuICogZGlzdHJpYnV0ZWQgdW5kZXIgdGhlIExpY2Vuc2UgaXMgZGlzdHJpYnV0ZWQgb24gYW4gXCJBUyBJU1wiIEJBU0lTLFxuICogV0lUSE9VVCBXQVJSQU5USUVTIE9SIENPTkRJVElPTlMgT0YgQU5ZIEtJTkQsIGVpdGhlciBleHByZXNzIG9yIGltcGxpZWQuXG4gKiBTZWUgdGhlIExpY2Vuc2UgZm9yIHRoZSBzcGVjaWZpYyBsYW5ndWFnZSBnb3Zlcm5pbmcgcGVybWlzc2lvbnMgYW5kXG4gKiBsaW1pdGF0aW9ucyB1bmRlciB0aGUgTGljZW5zZS5cbiAqL1xuXG4gLyogZXNsaW50LWRpc2FibGUgQGFuZ3VsYXItZXNsaW50L2NvbXBvbmVudC1zZWxlY3RvciAqL1xuXG4vKiBlc2xpbnQtZGlzYWJsZSAqL1xuaW1wb3J0IHsgRm9ybUZpZWxkTWV0YWRhdGEgfSBmcm9tICcuL2Zvcm0tZmllbGQtbWV0YWRhdGEnO1xuXG5leHBvcnQgaW50ZXJmYWNlIEZvcm1WYWx1ZXMgZXh0ZW5kcyBGb3JtRmllbGRNZXRhZGF0YSB7XG59XG4iXX0=

package/esm2022/lib/form/components/widgets/core/form-variable.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,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZm9ybS12YXJpYWJsZS5tb2RlbC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uLy4uLy4uLy4uL2xpYi9jb3JlL3NyYy9saWIvZm9ybS9jb21wb25lbnRzL3dpZGdldHMvY29yZS9mb3JtLXZhcmlhYmxlLm1vZGVsLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOzs7Ozs7Ozs7Ozs7Ozs7R0FlRyIsInNvdXJjZXNDb250ZW50IjpbIi8qIVxuICogQGxpY2Vuc2VcbiAqIENvcHlyaWdodCDCqSAyMDA1LTIwMjUgSHlsYW5kIFNvZnR3YXJlLCBJbmMuIGFuZCBpdHMgYWZmaWxpYXRlcy4gQWxsIHJpZ2h0cyByZXNlcnZlZC5cbiAqXG4gKiBMaWNlbnNlZCB1bmRlciB0aGUgQXBhY2hlIExpY2Vuc2UsIFZlcnNpb24gMi4wICh0aGUgXCJMaWNlbnNlXCIpO1xuICogeW91IG1heSBub3QgdXNlIHRoaXMgZmlsZSBleGNlcHQgaW4gY29tcGxpYW5jZSB3aXRoIHRoZSBMaWNlbnNlLlxuICogWW91IG1heSBvYnRhaW4gYSBjb3B5IG9mIHRoZSBMaWNlbnNlIGF0XG4gKlxuICogICAgIGh0dHA6Ly93d3cuYXBhY2hlLm9yZy9saWNlbnNlcy9MSUNFTlNFLTIuMFxuICpcbiAqIFVubGVzcyByZXF1aXJlZCBieSBhcHBsaWNhYmxlIGxhdyBvciBhZ3JlZWQgdG8gaW4gd3JpdGluZywgc29mdHdhcmVcbiAqIGRpc3RyaWJ1dGVkIHVuZGVyIHRoZSBMaWNlbnNlIGlzIGRpc3RyaWJ1dGVkIG9uIGFuIFwiQVMgSVNcIiBCQVNJUyxcbiAqIFdJVEhPVVQgV0FSUkFOVElFUyBPUiBDT05ESVRJT05TIE9GIEFOWSBLSU5ELCBlaXRoZXIgZXhwcmVzcyBvciBpbXBsaWVkLlxuICogU2VlIHRoZSBMaWNlbnNlIGZvciB0aGUgc3BlY2lmaWMgbGFuZ3VhZ2UgZ292ZXJuaW5nIHBlcm1pc3Npb25zIGFuZFxuICogbGltaXRhdGlvbnMgdW5kZXIgdGhlIExpY2Vuc2UuXG4gKi9cblxuZXhwb3J0IGludGVyZmFjZSBGb3JtVmFyaWFibGVNb2RlbCB7XG4gICAgaWQ6IHN0cmluZztcbiAgICBuYW1lOiBzdHJpbmc7XG4gICAgdHlwZTogc3RyaW5nO1xuICAgIHZhbHVlPzogYW55O1xufVxuIl19

package/esm2022/lib/form/components/widgets/core/form-widget.model.mjs

@@ -0,0 +1,33 @@
+/*!
+ * @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 */
+export class FormWidgetModel {
+    constructor(form, json) {
+        this.form = form;
+        this.json = json;
+        if (json) {
+            this.fieldType = json.fieldType;
+            this.id = json.id;
+            this.name = json.name;
+            this.type = json.type;
+            this.tab = json.tab;
+            this.field = json.field;
+            this.style = json.style;
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/form/components/widgets/core/form.model.mjs

@@ -0,0 +1,384 @@
+/*!
+ * @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 { FormFieldEvent } from '../../../events/form-field.event';
+import { ValidateFormFieldEvent } from '../../../events/validate-form-field.event';
+import { ValidateFormEvent } from '../../../events/validate-form.event';
+import { ContainerModel } from './container.model';
+import { FormFieldTypes } from './form-field-types';
+import { FormFieldModel } from './form-field.model';
+import { TabModel } from './tab.model';
+import { FormOutcomeModel } from './form-outcome.model';
+import { FORM_FIELD_VALIDATORS } from './form-field-validator';
+import { WidgetTypeEnum, WidgetVisibilityModel } from '../../../models/widget-visibility.model';
+export class FormModel {
+    static { this.UNSET_TASK_NAME = 'Nameless task'; }
+    static { this.SAVE_OUTCOME = '$save'; }
+    static { this.COMPLETE_OUTCOME = '$complete'; }
+    static { this.START_PROCESS_OUTCOME = '$startProcess'; }
+    constructor(json, formValues, readOnly = false, formService, enableFixedSpace, injectedFieldValidators) {
+        this.formService = formService;
+        this.taskName = FormModel.UNSET_TASK_NAME;
+        this.fieldsCache = [];
+        this.values = {};
+        this.tabs = [];
+        this.fields = [];
+        this.outcomes = [];
+        this.fieldValidators = [];
+        this.customFieldTemplates = {};
+        this.readOnly = false;
+        this.isValid = true;
+        this.processVariables = [];
+        this.variables = [];
+        this.readOnly = readOnly;
+        this.json = json;
+        if (json) {
+            this.id = json.id;
+            this.name = json.name;
+            this.taskId = json.taskId;
+            this.taskName = json.taskName || json.name || FormModel.UNSET_TASK_NAME;
+            this.processDefinitionId = json.processDefinitionId;
+            this.customFieldTemplates = json.customFieldTemplates || {};
+            this.selectedOutcome = json.selectedOutcome;
+            this.className = json.className || '';
+            this.variables = json.variables || json.formDefinition?.variables || [];
+            this.processVariables = json.processVariables || [];
+            this.enableFixedSpace = enableFixedSpace;
+            this.confirmMessage = json.confirmMessage || {};
+            this.displayMode = json.displayMode;
+            this.theme = json.theme || json.formDefinition?.theme;
+            this.tabs = (json.tabs || []).map((tabJson) => new TabModel(this, tabJson));
+            this.fields = this.parseRootFields(json);
+            this.fieldsCache = this.getFormFields();
+            if (formValues) {
+                this.loadData(formValues);
+            }
+            this.parseOutcomes();
+        }
+        this.loadInjectedFieldValidators(injectedFieldValidators);
+        this.validateForm();
+    }
+    onFormFieldChanged(field) {
+        this.validateField(field);
+        if (this.formService) {
+            this.formService.formFieldValueChanged.next(new FormFieldEvent(this, field));
+        }
+    }
+    /**
+     * Validates entire form and all form fields.
+     */
+    validateForm() {
+        const validateFormEvent = new ValidateFormEvent(this);
+        const errorsField = this.fieldsCache.filter((field) => {
+            if (!FormFieldTypes.isReactiveType(field.type)) {
+                return !field.validate();
+            }
+            else {
+                return field.validationSummary.isActive();
+            }
+        });
+        this.isValid = errorsField.length <= 0;
+        if (this.formService) {
+            validateFormEvent.isValid = this.isValid;
+            validateFormEvent.errorsField = errorsField;
+            this.formService.validateForm.next(validateFormEvent);
+        }
+    }
+    /**
+     * Validates a specific form field, triggers form validation.
+     *
+     * @param field Form field to validate.
+     */
+    validateField(field) {
+        if (!field) {
+            return;
+        }
+        const validateFieldEvent = new ValidateFormFieldEvent(this, field);
+        if (this.formService) {
+            this.formService.validateFormField.next(validateFieldEvent);
+        }
+        if (!validateFieldEvent.isValid) {
+            this.markAsInvalid();
+            return;
+        }
+        if (validateFieldEvent.defaultPrevented) {
+            return;
+        }
+        if (!FormFieldTypes.isReactiveType(field.type) && !field.validate()) {
+            this.markAsInvalid();
+        }
+        this.validateForm();
+    }
+    // Activiti supports 3 types of root fields: container|group|dynamic-table
+    parseRootFields(json) {
+        let fields = [];
+        if (json.fields) {
+            fields = json.fields;
+        }
+        else if (json.formDefinition?.fields) {
+            fields = json.formDefinition.fields;
+        }
+        const rootElements = [];
+        let currentRootElement;
+        for (const field of fields) {
+            if (field?.type === FormFieldTypes.DYNAMIC_TABLE) {
+                currentRootElement = new FormFieldModel(this, field);
+            }
+            else {
+                currentRootElement = new ContainerModel(new FormFieldModel(this, field));
+            }
+            if (field.tab) {
+                const tab = this.tabs.find((currentTab) => field.tab === currentTab.id);
+                if (tab) {
+                    tab.fields.push(currentRootElement);
+                }
+            }
+            rootElements.push(currentRootElement);
+        }
+        return rootElements;
+    }
+    // Loads external data and overrides field values
+    // Typically used when form definition and form data coming from different sources
+    loadData(formValues) {
+        for (const field of this.fieldsCache) {
+            const variableId = `variables.${field.name}`;
+            if (this.canOverrideFieldValueWithProcessValue(field, variableId, formValues)) {
+                field.json.value = formValues[variableId] || formValues[field.id];
+                field.value = field.parseValue(field.json);
+            }
+        }
+    }
+    canOverrideFieldValueWithProcessValue(field, variableId, formValues) {
+        return !FormFieldTypes.isConstantValueType(field.type) && (this.isDefined(formValues[variableId]) || this.isDefined(formValues[field.id]));
+    }
+    isDefined(value) {
+        return value !== undefined && value !== null;
+    }
+    /**
+     * Returns a form variable that matches the identifier.
+     *
+     * @param identifier The `name` or `id` value.
+     * @returns form variable model
+     */
+    getFormVariable(identifier) {
+        if (identifier) {
+            return this.variables.find((variable) => variable.name === identifier || variable.id === identifier);
+        }
+        return undefined;
+    }
+    /**
+     * Returns a value of the form variable that matches the identifier.
+     * Provides additional conversion of types (date, boolean).
+     *
+     * @param identifier The `name` or `id` value
+     * @returns form variable value
+     */
+    getDefaultFormVariableValue(identifier) {
+        const variable = this.getFormVariable(identifier);
+        if (variable && Object.prototype.hasOwnProperty.call(variable, 'value')) {
+            return this.parseValue(variable.type, variable.value);
+        }
+        return undefined;
+    }
+    /**
+     * Returns a process variable value.
+     * When mapping a process variable with a form variable the mapping
+     * is already resolved by the rest API with the name of variables.formVariableName
+     *
+     * @param name Variable name
+     * @returns process variable value
+     */
+    getProcessVariableValue(name) {
+        let value;
+        if (this.processVariables?.length) {
+            const names = [`variables.${name}`, name];
+            const processVariable = this.processVariables.find((entry) => names.includes(entry.name));
+            if (processVariable) {
+                value = this.parseValue(processVariable.type, processVariable.value);
+            }
+        }
+        if (!value) {
+            value = this.getDefaultFormVariableValue(name);
+        }
+        return value;
+    }
+    parseValue(type, value) {
+        if (type && value) {
+            switch (type) {
+                case 'date':
+                    return value.toString().includes('T') ? value : `${value}T00:00:00.000Z`;
+                case 'boolean':
+                    return typeof value === 'string' ? JSON.parse(value) : value;
+                default:
+                    return value;
+            }
+        }
+        return value;
+    }
+    hasTabs() {
+        return this.tabs && this.tabs.length > 0;
+    }
+    hasFields() {
+        return this.fields && this.fields.length > 0;
+    }
+    hasOutcomes() {
+        return this.outcomes && this.outcomes.length > 0;
+    }
+    getFieldById(fieldId) {
+        return this.fieldsCache.find((field) => field.id === fieldId);
+    }
+    getFormFields(filterTypes) {
+        if (this.fieldsCache?.length) {
+            return this.filterFieldsByType(this.fieldsCache, filterTypes);
+        }
+        const formFieldModel = [];
+        this.processFields(this.fields, formFieldModel);
+        return this.filterFieldsByType(formFieldModel, filterTypes);
+    }
+    processFields(fields, formFieldModel) {
+        fields.forEach((field) => {
+            if (this.isSectionField(field)) {
+                this.handleSectionField(field, formFieldModel);
+            }
+            else if (this.isContainerField(field)) {
+                this.handleContainerField(field, formFieldModel);
+            }
+            else {
+                this.handleSingleField(field, formFieldModel);
+            }
+        });
+    }
+    isContainerField(field) {
+        return field instanceof ContainerModel;
+    }
+    isSectionField(field) {
+        return field.type === FormFieldTypes.SECTION;
+    }
+    handleSectionField(section, formFieldModel) {
+        formFieldModel.push(section);
+        section.columns.forEach((column) => {
+            this.processFields(column.fields, formFieldModel);
+        });
+    }
+    handleContainerField(container, formFieldModel) {
+        formFieldModel.push(container.field);
+        container.field.columns.forEach((column) => {
+            this.processFields(column.fields, formFieldModel);
+        });
+    }
+    handleSingleField(field, formFieldModel) {
+        formFieldModel.push(field);
+        if (field.fields) {
+            this.processFields(Object.values(field.fields), formFieldModel);
+        }
+    }
+    filterFieldsByType(fields, types) {
+        if (!types?.length) {
+            return fields;
+        }
+        return fields.filter((field) => types.includes(field?.type));
+    }
+    markAsInvalid() {
+        this.isValid = false;
+    }
+    parseOutcomes() {
+        if (this.json.fields) {
+            const saveOutcome = new FormOutcomeModel(this, {
+                id: FormModel.SAVE_OUTCOME,
+                name: 'SAVE',
+                isSystem: true
+            });
+            const completeOutcome = new FormOutcomeModel(this, {
+                id: FormModel.COMPLETE_OUTCOME,
+                name: 'COMPLETE',
+                isSystem: true
+            });
+            const startProcessOutcome = new FormOutcomeModel(this, {
+                id: FormModel.START_PROCESS_OUTCOME,
+                name: 'START PROCESS',
+                isSystem: true
+            });
+            const customOutcomes = (this.json.outcomes || []).map((obj) => new FormOutcomeModel(this, obj));
+            this.outcomes = [saveOutcome].concat(customOutcomes.length > 0 ? customOutcomes : [completeOutcome, startProcessOutcome]);
+        }
+    }
+    addValuesNotPresent(valuesToSetIfNotPresent) {
+        this.fieldsCache.forEach((field) => {
+            if (valuesToSetIfNotPresent[field.id] && (!this.values[field.id] || this.isValidDropDown(field.id))) {
+                this.values[field.id] = valuesToSetIfNotPresent[field.id];
+                field.json.value = this.values[field.id];
+                field.value = field.parseValue(field.json);
+            }
+        });
+    }
+    isValidDropDown(key) {
+        const field = this.getFieldById(key);
+        if (field.type === FormFieldTypes.DROPDOWN) {
+            if (field.hasMultipleValues) {
+                return Array.isArray(this.values[key]);
+            }
+            return typeof this.values[key] === 'string' ? this.values[key] === 'empty' : Object.keys(this.values[key]).length === 0;
+        }
+        return false;
+    }
+    setNodeIdValueForViewersLinkedToUploadWidget(linkedUploadWidgetContentSelected) {
+        const linkedWidgetType = linkedUploadWidgetContentSelected?.options?.linkedWidgetType ?? 'uploadWidget';
+        const subscribedViewers = this.fieldsCache.filter((field) => linkedUploadWidgetContentSelected.uploadWidgetId === field.params[linkedWidgetType]);
+        subscribedViewers.forEach((viewer) => {
+            this.values[viewer.id] = linkedUploadWidgetContentSelected.id;
+            viewer.json.value = this.values[viewer.id];
+            viewer.value = viewer.parseValue(viewer.json);
+        });
+    }
+    changeFieldVisibility(fieldId, visibility) {
+        const visibilityRule = new WidgetVisibilityModel();
+        const field = this.getFieldById(fieldId);
+        if (field) {
+            visibilityRule.operator = visibility ? 'empty' : '!empty';
+            visibilityRule.leftType = WidgetTypeEnum.field;
+            field.visibilityCondition = visibilityRule;
+            field.isVisible = visibility;
+        }
+    }
+    changeFieldDisabled(fieldId, disabled) {
+        const field = this.getFieldById(fieldId);
+        if (field) {
+            field.readOnly = this.readOnly || disabled;
+        }
+    }
+    changeFieldRequired(fieldId, required) {
+        const field = this.getFieldById(fieldId);
+        if (field) {
+            field.required = required;
+        }
+    }
+    changeFieldValue(fieldId, value) {
+        const field = this.getFieldById(fieldId);
+        if (field) {
+            field.value = value;
+        }
+    }
+    changeVariableValue(variableId, value) {
+        const variable = this.getFormVariable(variableId);
+        if (variable) {
+            variable.value = value;
+        }
+    }
+    loadInjectedFieldValidators(injectedFieldValidators) {
+        this.fieldValidators = injectedFieldValidators ? [...FORM_FIELD_VALIDATORS, ...injectedFieldValidators] : [...FORM_FIELD_VALIDATORS];
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"form.model.js","sourceRoot":"","sources":["../../../../../../../../../lib/core/src/lib/form/components/widgets/core/form.model.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 { FormFieldEvent } from '../../../events/form-field.event';\nimport { ValidateFormFieldEvent } from '../../../events/validate-form-field.event';\nimport { ValidateFormEvent } from '../../../events/validate-form.event';\nimport { ContainerModel } from './container.model';\nimport { FormFieldTypes } from './form-field-types';\nimport { FormFieldModel } from './form-field.model';\nimport { FormValues } from './form-values';\nimport { TabModel } from './tab.model';\n\nimport { FormVariableModel } from './form-variable.model';\nimport { ProcessVariableModel } from './process-variable.model';\nimport { FormOutcomeModel } from './form-outcome.model';\nimport { FormFieldValidator, FORM_FIELD_VALIDATORS } from './form-field-validator';\nimport { FormFieldTemplates } from './form-field-templates';\nimport { UploadWidgetContentLinkModel } from './upload-widget-content-link.model';\nimport { FormValidationService } from '../../../services/form-validation-service.interface';\nimport { ProcessFormModel } from './process-form-model.interface';\nimport { WidgetTypeEnum, WidgetVisibilityModel } from '../../../models/widget-visibility.model';\nimport { ThemeModel } from './theme.model';\n\nexport interface ConfirmMessage {\n    show: boolean;\n    message: string;\n}\nexport interface FormRepresentationModel {\n    [key: string]: any;\n\n    id?: string | number;\n    name?: string;\n    taskId?: string;\n    taskName?: string;\n    processDefinitionId?: string;\n    customFieldTemplates?: {\n        [key: string]: string;\n    };\n    selectedOutcome?: string;\n    fields?: any[];\n    tabs?: any[];\n    outcomes?: any[];\n    formDefinition?: {\n        [key: string]: any;\n        fields?: any[];\n    };\n    displayMode: string;\n    theme?: ThemeModel;\n}\nexport class FormModel implements ProcessFormModel {\n    static UNSET_TASK_NAME: string = 'Nameless task';\n    static SAVE_OUTCOME: string = '$save';\n    static COMPLETE_OUTCOME: string = '$complete';\n    static START_PROCESS_OUTCOME: string = '$startProcess';\n\n    readonly id: string | number;\n    readonly name: string;\n    readonly taskId: string;\n    readonly confirmMessage: ConfirmMessage;\n    readonly taskName = FormModel.UNSET_TASK_NAME;\n    readonly processDefinitionId: string;\n    readonly selectedOutcome: string;\n    readonly enableFixedSpace: boolean;\n    readonly displayMode: any;\n\n    fieldsCache: FormFieldModel[] = [];\n\n    json: any;\n    nodeId: string;\n    values: FormValues = {};\n    tabs: TabModel[] = [];\n    fields: (ContainerModel | FormFieldModel)[] = [];\n    outcomes: FormOutcomeModel[] = [];\n    fieldValidators: FormFieldValidator[] = [];\n    customFieldTemplates: FormFieldTemplates = {};\n    theme?: ThemeModel;\n\n    className: string;\n    readOnly = false;\n    isValid = true;\n    processVariables: ProcessVariableModel[] = [];\n    variables: FormVariableModel[] = [];\n\n    constructor(\n        json?: any,\n        formValues?: FormValues,\n        readOnly: boolean = false,\n        protected formService?: FormValidationService,\n        enableFixedSpace?: boolean,\n        injectedFieldValidators?: FormFieldValidator[]\n    ) {\n        this.readOnly = readOnly;\n        this.json = json;\n\n        if (json) {\n            this.id = json.id;\n            this.name = json.name;\n            this.taskId = json.taskId;\n            this.taskName = json.taskName || json.name || FormModel.UNSET_TASK_NAME;\n            this.processDefinitionId = json.processDefinitionId;\n            this.customFieldTemplates = json.customFieldTemplates || {};\n            this.selectedOutcome = json.selectedOutcome;\n            this.className = json.className || '';\n            this.variables = json.variables || json.formDefinition?.variables || [];\n            this.processVariables = json.processVariables || [];\n            this.enableFixedSpace = enableFixedSpace;\n            this.confirmMessage = json.confirmMessage || {};\n            this.displayMode = json.displayMode;\n            this.theme = json.theme || json.formDefinition?.theme;\n\n            this.tabs = (json.tabs || []).map((tabJson) => new TabModel(this, tabJson));\n\n            this.fields = this.parseRootFields(json);\n            this.fieldsCache = this.getFormFields();\n\n            if (formValues) {\n                this.loadData(formValues);\n            }\n\n            this.parseOutcomes();\n        }\n\n        this.loadInjectedFieldValidators(injectedFieldValidators);\n        this.validateForm();\n    }\n\n    onFormFieldChanged(field: FormFieldModel) {\n        this.validateField(field);\n\n        if (this.formService) {\n            this.formService.formFieldValueChanged.next(new FormFieldEvent(this, field));\n        }\n    }\n\n    /**\n     * Validates entire form and all form fields.\n     */\n    validateForm(): void {\n        const validateFormEvent: any = new ValidateFormEvent(this);\n\n        const errorsField: FormFieldModel[] = this.fieldsCache.filter((field) => {\n            if (!FormFieldTypes.isReactiveType(field.type)) {\n                return !field.validate();\n            } else {\n                return field.validationSummary.isActive();\n            }\n        });\n\n        this.isValid = errorsField.length <= 0;\n\n        if (this.formService) {\n            validateFormEvent.isValid = this.isValid;\n            validateFormEvent.errorsField = errorsField;\n            this.formService.validateForm.next(validateFormEvent);\n        }\n    }\n\n    /**\n     * Validates a specific form field, triggers form validation.\n     *\n     * @param field Form field to validate.\n     */\n    validateField(field: FormFieldModel): void {\n        if (!field) {\n            return;\n        }\n\n        const validateFieldEvent = new ValidateFormFieldEvent(this, field);\n\n        if (this.formService) {\n            this.formService.validateFormField.next(validateFieldEvent);\n        }\n\n        if (!validateFieldEvent.isValid) {\n            this.markAsInvalid();\n            return;\n        }\n\n        if (validateFieldEvent.defaultPrevented) {\n            return;\n        }\n\n        if (!FormFieldTypes.isReactiveType(field.type) && !field.validate()) {\n            this.markAsInvalid();\n        }\n\n        this.validateForm();\n    }\n\n    // Activiti supports 3 types of root fields: container|group|dynamic-table\n    private parseRootFields(json: any): (ContainerModel | FormFieldModel)[] {\n        let fields = [];\n\n        if (json.fields) {\n            fields = json.fields;\n        } else if (json.formDefinition?.fields) {\n            fields = json.formDefinition.fields;\n        }\n\n        const rootElements: (ContainerModel | FormFieldModel)[] = [];\n        let currentRootElement;\n        for (const field of fields) {\n            if (field?.type === FormFieldTypes.DYNAMIC_TABLE) {\n                currentRootElement = new FormFieldModel(this, field);\n            } else {\n                currentRootElement = new ContainerModel(new FormFieldModel(this, field));\n            }\n\n            if (field.tab) {\n                const tab = this.tabs.find((currentTab) => field.tab === currentTab.id);\n                if (tab) {\n                    tab.fields.push(currentRootElement);\n                }\n            }\n\n            rootElements.push(currentRootElement);\n        }\n\n        return rootElements;\n    }\n\n    // Loads external data and overrides field values\n    // Typically used when form definition and form data coming from different sources\n    private loadData(formValues: FormValues) {\n        for (const field of this.fieldsCache) {\n            const variableId = `variables.${field.name}`;\n\n            if (this.canOverrideFieldValueWithProcessValue(field, variableId, formValues)) {\n                field.json.value = formValues[variableId] || formValues[field.id];\n                field.value = field.parseValue(field.json);\n            }\n        }\n    }\n\n    private canOverrideFieldValueWithProcessValue(field: FormFieldModel, variableId: string, formValues: FormValues): boolean {\n        return !FormFieldTypes.isConstantValueType(field.type) && (this.isDefined(formValues[variableId]) || this.isDefined(formValues[field.id]));\n    }\n\n    private isDefined(value: string): boolean {\n        return value !== undefined && value !== null;\n    }\n\n    /**\n     * Returns a form variable that matches the identifier.\n     *\n     * @param identifier The `name` or `id` value.\n     * @returns form variable model\n     */\n    getFormVariable(identifier: string): FormVariableModel {\n        if (identifier) {\n            return this.variables.find((variable) => variable.name === identifier || variable.id === identifier);\n        }\n        return undefined;\n    }\n\n    /**\n     * Returns a value of the form variable that matches the identifier.\n     * Provides additional conversion of types (date, boolean).\n     *\n     * @param identifier The `name` or `id` value\n     * @returns form variable value\n     */\n    getDefaultFormVariableValue(identifier: string): any {\n        const variable = this.getFormVariable(identifier);\n\n        if (variable && Object.prototype.hasOwnProperty.call(variable, 'value')) {\n            return this.parseValue(variable.type, variable.value);\n        }\n\n        return undefined;\n    }\n\n    /**\n     * Returns a process variable value.\n     * When mapping a process variable with a form variable the mapping\n     * is already resolved by the rest API with the name of variables.formVariableName\n     *\n     * @param name Variable name\n     * @returns process variable value\n     */\n    getProcessVariableValue(name: string): any {\n        let value;\n        if (this.processVariables?.length) {\n            const names = [`variables.${name}`, name];\n\n            const processVariable = this.processVariables.find((entry) => names.includes(entry.name));\n\n            if (processVariable) {\n                value = this.parseValue(processVariable.type, processVariable.value);\n            }\n        }\n\n        if (!value) {\n            value = this.getDefaultFormVariableValue(name);\n        }\n\n        return value;\n    }\n\n    protected parseValue(type: string, value: any): any {\n        if (type && value) {\n            switch (type) {\n                case 'date':\n                    return value.toString().includes('T') ? value : `${value}T00:00:00.000Z`;\n                case 'boolean':\n                    return typeof value === 'string' ? JSON.parse(value) : value;\n                default:\n                    return value;\n            }\n        }\n\n        return value;\n    }\n\n    hasTabs(): boolean {\n        return this.tabs && this.tabs.length > 0;\n    }\n\n    hasFields(): boolean {\n        return this.fields && this.fields.length > 0;\n    }\n\n    hasOutcomes(): boolean {\n        return this.outcomes && this.outcomes.length > 0;\n    }\n\n    getFieldById(fieldId: string): FormFieldModel {\n        return this.fieldsCache.find((field) => field.id === fieldId);\n    }\n\n    getFormFields(filterTypes?: string[]): FormFieldModel[] {\n        if (this.fieldsCache?.length) {\n            return this.filterFieldsByType(this.fieldsCache, filterTypes);\n        }\n\n        const formFieldModel: FormFieldModel[] = [];\n        this.processFields(this.fields, formFieldModel);\n        return this.filterFieldsByType(formFieldModel, filterTypes);\n    }\n\n    private processFields(fields: (ContainerModel | FormFieldModel)[], formFieldModel: FormFieldModel[]): void {\n        fields.forEach((field) => {\n            if (this.isSectionField(field)) {\n                this.handleSectionField(field, formFieldModel);\n            } else if (this.isContainerField(field)) {\n                this.handleContainerField(field, formFieldModel);\n            } else {\n                this.handleSingleField(field, formFieldModel);\n            }\n        });\n    }\n\n    private isContainerField(field: ContainerModel | FormFieldModel): field is ContainerModel {\n        return field instanceof ContainerModel;\n    }\n\n    private isSectionField(field: ContainerModel | FormFieldModel): field is FormFieldModel {\n        return field.type === FormFieldTypes.SECTION;\n    }\n\n    private handleSectionField(section: FormFieldModel, formFieldModel: FormFieldModel[]): void {\n        formFieldModel.push(section);\n        section.columns.forEach((column) => {\n            this.processFields(column.fields, formFieldModel);\n        });\n    }\n\n    private handleContainerField(container: ContainerModel, formFieldModel: FormFieldModel[]): void {\n        formFieldModel.push(container.field);\n        container.field.columns.forEach((column) => {\n            this.processFields(column.fields, formFieldModel);\n        });\n    }\n\n    private handleSingleField(field: FormFieldModel, formFieldModel: FormFieldModel[]): void {\n        formFieldModel.push(field);\n        if (field.fields) {\n            this.processFields(Object.values(field.fields), formFieldModel);\n        }\n    }\n\n    private filterFieldsByType(fields: FormFieldModel[], types?: string[]): FormFieldModel[] {\n        if (!types?.length) {\n            return fields;\n        }\n\n        return fields.filter((field) => types.includes(field?.type));\n    }\n\n    markAsInvalid(): void {\n        this.isValid = false;\n    }\n\n    protected parseOutcomes() {\n        if (this.json.fields) {\n            const saveOutcome = new FormOutcomeModel(this, {\n                id: FormModel.SAVE_OUTCOME,\n                name: 'SAVE',\n                isSystem: true\n            });\n            const completeOutcome = new FormOutcomeModel(this, {\n                id: FormModel.COMPLETE_OUTCOME,\n                name: 'COMPLETE',\n                isSystem: true\n            });\n            const startProcessOutcome = new FormOutcomeModel(this, {\n                id: FormModel.START_PROCESS_OUTCOME,\n                name: 'START PROCESS',\n                isSystem: true\n            });\n\n            const customOutcomes = (this.json.outcomes || []).map((obj) => new FormOutcomeModel(this, obj));\n\n            this.outcomes = [saveOutcome].concat(customOutcomes.length > 0 ? customOutcomes : [completeOutcome, startProcessOutcome]);\n        }\n    }\n\n    addValuesNotPresent(valuesToSetIfNotPresent: FormValues) {\n        this.fieldsCache.forEach((field) => {\n            if (valuesToSetIfNotPresent[field.id] && (!this.values[field.id] || this.isValidDropDown(field.id))) {\n                this.values[field.id] = valuesToSetIfNotPresent[field.id];\n                field.json.value = this.values[field.id];\n                field.value = field.parseValue(field.json);\n            }\n        });\n    }\n\n    private isValidDropDown(key: string): boolean {\n        const field = this.getFieldById(key);\n        if (field.type === FormFieldTypes.DROPDOWN) {\n            if (field.hasMultipleValues) {\n                return Array.isArray(this.values[key]);\n            }\n            return typeof this.values[key] === 'string' ? this.values[key] === 'empty' : Object.keys(this.values[key]).length === 0;\n        }\n        return false;\n    }\n\n    setNodeIdValueForViewersLinkedToUploadWidget(linkedUploadWidgetContentSelected: UploadWidgetContentLinkModel) {\n        const linkedWidgetType = linkedUploadWidgetContentSelected?.options?.linkedWidgetType ?? 'uploadWidget';\n\n        const subscribedViewers = this.fieldsCache.filter(\n            (field) => linkedUploadWidgetContentSelected.uploadWidgetId === field.params[linkedWidgetType]\n        );\n\n        subscribedViewers.forEach((viewer) => {\n            this.values[viewer.id] = linkedUploadWidgetContentSelected.id;\n            viewer.json.value = this.values[viewer.id];\n            viewer.value = viewer.parseValue(viewer.json);\n        });\n    }\n\n    changeFieldVisibility(fieldId: string, visibility: boolean): void {\n        const visibilityRule: WidgetVisibilityModel = new WidgetVisibilityModel();\n\n        const field = this.getFieldById(fieldId);\n        if (field) {\n            visibilityRule.operator = visibility ? 'empty' : '!empty';\n            visibilityRule.leftType = WidgetTypeEnum.field;\n            field.visibilityCondition = visibilityRule;\n            field.isVisible = visibility;\n        }\n    }\n\n    changeFieldDisabled(fieldId: string, disabled: boolean): void {\n        const field = this.getFieldById(fieldId);\n        if (field) {\n            field.readOnly = this.readOnly || disabled;\n        }\n    }\n\n    changeFieldRequired(fieldId: string, required: boolean): void {\n        const field = this.getFieldById(fieldId);\n        if (field) {\n            field.required = required;\n        }\n    }\n\n    changeFieldValue(fieldId: string, value: any): void {\n        const field = this.getFieldById(fieldId);\n        if (field) {\n            field.value = value;\n        }\n    }\n\n    changeVariableValue(variableId: string, value: any): void {\n        const variable = this.getFormVariable(variableId);\n        if (variable) {\n            variable.value = value;\n        }\n    }\n\n    private loadInjectedFieldValidators(injectedFieldValidators: FormFieldValidator[]): void {\n        this.fieldValidators = injectedFieldValidators ? [...FORM_FIELD_VALIDATORS, ...injectedFieldValidators] : [...FORM_FIELD_VALIDATORS];\n    }\n}\n"]}

package/esm2022/lib/form/components/widgets/core/group.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,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZ3JvdXAubW9kZWwuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi9saWIvY29yZS9zcmMvbGliL2Zvcm0vY29tcG9uZW50cy93aWRnZXRzL2NvcmUvZ3JvdXAubW9kZWwudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7Ozs7Ozs7Ozs7Ozs7OztHQWVHIiwic291cmNlc0NvbnRlbnQiOlsiLyohXG4gKiBAbGljZW5zZVxuICogQ29weXJpZ2h0IMKpIDIwMDUtMjAyNSBIeWxhbmQgU29mdHdhcmUsIEluYy4gYW5kIGl0cyBhZmZpbGlhdGVzLiBBbGwgcmlnaHRzIHJlc2VydmVkLlxuICpcbiAqIExpY2Vuc2VkIHVuZGVyIHRoZSBBcGFjaGUgTGljZW5zZSwgVmVyc2lvbiAyLjAgKHRoZSBcIkxpY2Vuc2VcIik7XG4gKiB5b3UgbWF5IG5vdCB1c2UgdGhpcyBmaWxlIGV4Y2VwdCBpbiBjb21wbGlhbmNlIHdpdGggdGhlIExpY2Vuc2UuXG4gKiBZb3UgbWF5IG9idGFpbiBhIGNvcHkgb2YgdGhlIExpY2Vuc2UgYXRcbiAqXG4gKiAgICAgaHR0cDovL3d3dy5hcGFjaGUub3JnL2xpY2Vuc2VzL0xJQ0VOU0UtMi4wXG4gKlxuICogVW5sZXNzIHJlcXVpcmVkIGJ5IGFwcGxpY2FibGUgbGF3IG9yIGFncmVlZCB0byBpbiB3cml0aW5nLCBzb2Z0d2FyZVxuICogZGlzdHJpYnV0ZWQgdW5kZXIgdGhlIExpY2Vuc2UgaXMgZGlzdHJpYnV0ZWQgb24gYW4gXCJBUyBJU1wiIEJBU0lTLFxuICogV0lUSE9VVCBXQVJSQU5USUVTIE9SIENPTkRJVElPTlMgT0YgQU5ZIEtJTkQsIGVpdGhlciBleHByZXNzIG9yIGltcGxpZWQuXG4gKiBTZWUgdGhlIExpY2Vuc2UgZm9yIHRoZSBzcGVjaWZpYyBsYW5ndWFnZSBnb3Zlcm5pbmcgcGVybWlzc2lvbnMgYW5kXG4gKiBsaW1pdGF0aW9ucyB1bmRlciB0aGUgTGljZW5zZS5cbiAqL1xuXG5leHBvcnQgaW50ZXJmYWNlIEdyb3VwTW9kZWwge1xuICAgIGV4dGVybmFsSWQ/OiBzdHJpbmc7XG4gICAgZ3JvdXBzPzogYW55O1xuICAgIGlkPzogc3RyaW5nO1xuICAgIG5hbWU/OiBzdHJpbmc7XG4gICAgc3RhdHVzPzogc3RyaW5nO1xufVxuIl19