@alfresco/adf-core 8.1.0-16295248176 → 8.1.0-16320806191

package/esm2022/lib/form/models/widget-visibility.model.mjs

@@ -0,0 +1,104 @@
+/*!
+ * @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 WidgetVisibilityModel {
+    constructor(json) {
+        this.json = json;
+        if (json) {
+            this.operator = json.operator;
+            this.nextCondition = new WidgetVisibilityModel(json.nextCondition);
+            this.nextConditionOperator = json.nextConditionOperator;
+            this.rightRestResponseId = json.rightRestResponseId;
+            this.rightFormFieldId = json.rightFormFieldId;
+            this.leftFormFieldId = json.leftFormFieldId;
+            this.leftRestResponseId = json.leftRestResponseId;
+        }
+        else {
+            this.json = {};
+        }
+    }
+    get leftType() {
+        if (this.leftFormFieldId) {
+            return WidgetTypeEnum.field;
+        }
+        else if (this.leftRestResponseId) {
+            return WidgetTypeEnum.variable;
+        }
+        else if (this.json.leftType) {
+            return this.json.leftType;
+        }
+        return null;
+    }
+    set leftType(leftType) {
+        this.json.leftType = leftType;
+    }
+    get leftValue() {
+        if (this.json.leftValue?.toString()) {
+            return this.json.leftValue;
+        }
+        else if (this.leftFormFieldId) {
+            return this.leftFormFieldId;
+        }
+        else if (this.leftRestResponseId) {
+            return this.leftRestResponseId;
+        }
+        return null;
+    }
+    set leftValue(leftValue) {
+        this.json.leftValue = leftValue;
+    }
+    get rightType() {
+        if (this.json.rightType) {
+            return this.json.rightType;
+        }
+        else if (this.json.rightValue) {
+            return WidgetTypeEnum.value;
+        }
+        else if (this.rightRestResponseId) {
+            return WidgetTypeEnum.variable;
+        }
+        else if (this.rightFormFieldId) {
+            return WidgetTypeEnum.field;
+        }
+        return null;
+    }
+    set rightType(rightType) {
+        this.json.rightType = rightType;
+    }
+    get rightValue() {
+        if (this.json.rightValue?.toString()) {
+            return this.json.rightValue;
+        }
+        else if (this.rightFormFieldId) {
+            return this.rightFormFieldId;
+        }
+        else if (this.rightRestResponseId) {
+            return this.rightRestResponseId;
+        }
+        return null;
+    }
+    set rightValue(rightValue) {
+        this.json.rightValue = rightValue;
+    }
+}
+// eslint-disable-next-line no-shadow
+export var WidgetTypeEnum;
+(function (WidgetTypeEnum) {
+    WidgetTypeEnum["field"] = "field";
+    WidgetTypeEnum["variable"] = "variable";
+    WidgetTypeEnum["value"] = "value";
+})(WidgetTypeEnum || (WidgetTypeEnum = {}));
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"widget-visibility.model.js","sourceRoot":"","sources":["../../../../../../../lib/core/src/lib/form/models/widget-visibility.model.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAEH,MAAM,OAAO,qBAAqB;IAS9B,YAAoB,IAAU;QAAV,SAAI,GAAJ,IAAI,CAAM;QAC1B,IAAI,IAAI,EAAE,CAAC;YACP,IAAI,CAAC,QAAQ,GAAG,IAAI,CAAC,QAAQ,CAAC;YAC9B,IAAI,CAAC,aAAa,GAAG,IAAI,qBAAqB,CAAC,IAAI,CAAC,aAAa,CAAC,CAAC;YACnE,IAAI,CAAC,qBAAqB,GAAG,IAAI,CAAC,qBAAqB,CAAC;YACxD,IAAI,CAAC,mBAAmB,GAAG,IAAI,CAAC,mBAAmB,CAAC;YACpD,IAAI,CAAC,gBAAgB,GAAG,IAAI,CAAC,gBAAgB,CAAC;YAC9C,IAAI,CAAC,eAAe,GAAG,IAAI,CAAC,eAAe,CAAC;YAC5C,IAAI,CAAC,kBAAkB,GAAG,IAAI,CAAC,kBAAkB,CAAC;QACtD,CAAC;aAAM,CAAC;YACJ,IAAI,CAAC,IAAI,GAAG,EAAE,CAAC;QACnB,CAAC;IACL,CAAC;IAED,IAAI,QAAQ;QACR,IAAI,IAAI,CAAC,eAAe,EAAE,CAAC;YACvB,OAAO,cAAc,CAAC,KAAK,CAAC;QAChC,CAAC;aAAM,IAAI,IAAI,CAAC,kBAAkB,EAAE,CAAC;YACjC,OAAO,cAAc,CAAC,QAAQ,CAAC;QACnC,CAAC;aAAM,IAAI,IAAI,CAAC,IAAI,CAAC,QAAQ,EAAE,CAAC;YAC5B,OAAO,IAAI,CAAC,IAAI,CAAC,QAAQ,CAAC;QAC9B,CAAC;QACD,OAAO,IAAI,CAAC;IAChB,CAAC;IAED,IAAI,QAAQ,CAAC,QAAgB;QACzB,IAAI,CAAC,IAAI,CAAC,QAAQ,GAAG,QAAQ,CAAC;IAClC,CAAC;IAED,IAAI,SAAS;QACT,IAAI,IAAI,CAAC,IAAI,CAAC,SAAS,EAAE,QAAQ,EAAE,EAAE,CAAC;YAClC,OAAO,IAAI,CAAC,IAAI,CAAC,SAAS,CAAC;QAC/B,CAAC;aAAM,IAAI,IAAI,CAAC,eAAe,EAAE,CAAC;YAC9B,OAAO,IAAI,CAAC,eAAe,CAAC;QAChC,CAAC;aAAM,IAAI,IAAI,CAAC,kBAAkB,EAAE,CAAC;YACjC,OAAO,IAAI,CAAC,kBAAkB,CAAC;QACnC,CAAC;QACD,OAAO,IAAI,CAAC;IAChB,CAAC;IAED,IAAI,SAAS,CAAC,SAAc;QACxB,IAAI,CAAC,IAAI,CAAC,SAAS,GAAG,SAAS,CAAC;IACpC,CAAC;IAED,IAAI,SAAS;QACT,IAAI,IAAI,CAAC,IAAI,CAAC,SAAS,EAAE,CAAC;YACtB,OAAO,IAAI,CAAC,IAAI,CAAC,SAAS,CAAC;QAC/B,CAAC;aAAM,IAAI,IAAI,CAAC,IAAI,CAAC,UAAU,EAAE,CAAC;YAC9B,OAAO,cAAc,CAAC,KAAK,CAAC;QAChC,CAAC;aAAM,IAAI,IAAI,CAAC,mBAAmB,EAAE,CAAC;YAClC,OAAO,cAAc,CAAC,QAAQ,CAAC;QACnC,CAAC;aAAM,IAAI,IAAI,CAAC,gBAAgB,EAAE,CAAC;YAC/B,OAAO,cAAc,CAAC,KAAK,CAAC;QAChC,CAAC;QAED,OAAO,IAAI,CAAC;IAChB,CAAC;IAED,IAAI,SAAS,CAAC,SAAwB;QAClC,IAAI,CAAC,IAAI,CAAC,SAAS,GAAG,SAAS,CAAC;IACpC,CAAC;IAED,IAAI,UAAU;QACV,IAAI,IAAI,CAAC,IAAI,CAAC,UAAU,EAAE,QAAQ,EAAE,EAAE,CAAC;YACnC,OAAO,IAAI,CAAC,IAAI,CAAC,UAAU,CAAC;QAChC,CAAC;aAAM,IAAI,IAAI,CAAC,gBAAgB,EAAE,CAAC;YAC/B,OAAO,IAAI,CAAC,gBAAgB,CAAC;QACjC,CAAC;aAAM,IAAI,IAAI,CAAC,mBAAmB,EAAE,CAAC;YAClC,OAAO,IAAI,CAAC,mBAAmB,CAAC;QACpC,CAAC;QACD,OAAO,IAAI,CAAC;IAChB,CAAC;IAED,IAAI,UAAU,CAAC,UAAe;QAC1B,IAAI,CAAC,IAAI,CAAC,UAAU,GAAG,UAAU,CAAC;IACtC,CAAC;CACJ;AAED,qCAAqC;AACrC,MAAM,CAAN,IAAY,cAIX;AAJD,WAAY,cAAc;IACtB,iCAAe,CAAA;IACf,uCAAqB,CAAA;IACrB,iCAAe,CAAA;AACnB,CAAC,EAJW,cAAc,KAAd,cAAc,QAIzB","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\nexport class WidgetVisibilityModel {\n    rightRestResponseId?: string;\n    rightFormFieldId?: string;\n    leftRestResponseId?: string;\n    leftFormFieldId?: string;\n    operator: string;\n    nextCondition?: WidgetVisibilityModel;\n    nextConditionOperator: string;\n\n    constructor(private json?: any) {\n        if (json) {\n            this.operator = json.operator;\n            this.nextCondition = new WidgetVisibilityModel(json.nextCondition);\n            this.nextConditionOperator = json.nextConditionOperator;\n            this.rightRestResponseId = json.rightRestResponseId;\n            this.rightFormFieldId = json.rightFormFieldId;\n            this.leftFormFieldId = json.leftFormFieldId;\n            this.leftRestResponseId = json.leftRestResponseId;\n        } else {\n            this.json = {};\n        }\n    }\n\n    get leftType(): string | null {\n        if (this.leftFormFieldId) {\n            return WidgetTypeEnum.field;\n        } else if (this.leftRestResponseId) {\n            return WidgetTypeEnum.variable;\n        } else if (this.json.leftType) {\n            return this.json.leftType;\n        }\n        return null;\n    }\n\n    set leftType(leftType: string) {\n        this.json.leftType = leftType;\n    }\n\n    get leftValue(): any {\n        if (this.json.leftValue?.toString()) {\n            return this.json.leftValue;\n        } else if (this.leftFormFieldId) {\n            return this.leftFormFieldId;\n        } else if (this.leftRestResponseId) {\n            return this.leftRestResponseId;\n        }\n        return null;\n    }\n\n    set leftValue(leftValue: any) {\n        this.json.leftValue = leftValue;\n    }\n\n    get rightType(): string | null {\n        if (this.json.rightType) {\n            return this.json.rightType;\n        } else if (this.json.rightValue) {\n            return WidgetTypeEnum.value;\n        } else if (this.rightRestResponseId) {\n            return WidgetTypeEnum.variable;\n        } else if (this.rightFormFieldId) {\n            return WidgetTypeEnum.field;\n        }\n\n        return null;\n    }\n\n    set rightType(rightType: string | null) {\n        this.json.rightType = rightType;\n    }\n\n    get rightValue(): any {\n        if (this.json.rightValue?.toString()) {\n            return this.json.rightValue;\n        } else if (this.rightFormFieldId) {\n            return this.rightFormFieldId;\n        } else if (this.rightRestResponseId) {\n            return this.rightRestResponseId;\n        }\n        return null;\n    }\n\n    set rightValue(rightValue: any) {\n        this.json.rightValue = rightValue;\n    }\n}\n\n// eslint-disable-next-line no-shadow\nexport enum WidgetTypeEnum {\n    field = 'field',\n    variable = 'variable',\n    value = 'value'\n}\n"]}

package/esm2022/lib/form/pipes/field-style.pipe.mjs

@@ -0,0 +1,45 @@
+/*!
+ * @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 { Pipe } from '@angular/core';
+import { predefinedTheme } from '../components/widgets/core/predefined-theme';
+import * as i0 from "@angular/core";
+export class FieldStylePipe {
+    transform(field) {
+        if (!field.style) {
+            return '';
+        }
+        const themeStyle = field.form?.theme?.widgets[field.type]?.[field.style];
+        const predefinedThemeStyle = predefinedTheme.widgets[field.type]?.[field.style];
+        const styles = (themeStyle || predefinedThemeStyle)?.styles;
+        return styles ? this.flattenStyles(styles) : '';
+    }
+    flattenStyles(styles) {
+        return Object.entries(styles)
+            .map(([key, value]) => `${key}:${value};`)
+            .join('');
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: FieldStylePipe, deps: [], target: i0.ɵɵFactoryTarget.Pipe }); }
+    static { this.ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "14.0.0", version: "18.2.13", ngImport: i0, type: FieldStylePipe, isStandalone: true, name: "adfFieldStyle" }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: FieldStylePipe, decorators: [{
+            type: Pipe,
+            args: [{
+                    name: 'adfFieldStyle',
+                    standalone: true
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZmllbGQtc3R5bGUucGlwZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uLy4uL2xpYi9jb3JlL3NyYy9saWIvZm9ybS9waXBlcy9maWVsZC1zdHlsZS5waXBlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOzs7Ozs7Ozs7Ozs7Ozs7R0FlRztBQUVILE9BQU8sRUFBRSxJQUFJLEVBQWlCLE1BQU0sZUFBZSxDQUFDO0FBR3BELE9BQU8sRUFBRSxlQUFlLEVBQUUsTUFBTSw2Q0FBNkMsQ0FBQzs7QUFNOUUsTUFBTSxPQUFPLGNBQWM7SUFDdkIsU0FBUyxDQUFDLEtBQXNDO1FBQzVDLElBQUksQ0FBQyxLQUFLLENBQUMsS0FBSyxFQUFFLENBQUM7WUFDZixPQUFPLEVBQUUsQ0FBQztRQUNkLENBQUM7UUFFRCxNQUFNLFVBQVUsR0FBRyxLQUFLLENBQUMsSUFBSSxFQUFFLEtBQUssRUFBRSxPQUFPLENBQUMsS0FBSyxDQUFDLElBQUksQ0FBQyxFQUFFLENBQUMsS0FBSyxDQUFDLEtBQUssQ0FBQyxDQUFDO1FBQ3pFLE1BQU0sb0JBQW9CLEdBQUcsZUFBZSxDQUFDLE9BQU8sQ0FBQyxLQUFLLENBQUMsSUFBSSxDQUFDLEVBQUUsQ0FBQyxLQUFLLENBQUMsS0FBSyxDQUFDLENBQUM7UUFDaEYsTUFBTSxNQUFNLEdBQUcsQ0FBQyxVQUFVLElBQUksb0JBQW9CLENBQUMsRUFBRSxNQUFNLENBQUM7UUFFNUQsT0FBTyxNQUFNLENBQUMsQ0FBQyxDQUFDLElBQUksQ0FBQyxhQUFhLENBQUMsTUFBTSxDQUFDLENBQUMsQ0FBQyxDQUFDLEVBQUUsQ0FBQztJQUNwRCxDQUFDO0lBRU8sYUFBYSxDQUFDLE1BQWlDO1FBQ25ELE9BQU8sTUFBTSxDQUFDLE9BQU8sQ0FBQyxNQUFNLENBQUM7YUFDeEIsR0FBRyxDQUFDLENBQUMsQ0FBQyxHQUFHLEVBQUUsS0FBSyxDQUFDLEVBQUUsRUFBRSxDQUFDLEdBQUcsR0FBRyxJQUFJLEtBQUssR0FBRyxDQUFDO2FBQ3pDLElBQUksQ0FBQyxFQUFFLENBQUMsQ0FBQztJQUNsQixDQUFDOytHQWpCUSxjQUFjOzZHQUFkLGNBQWM7OzRGQUFkLGNBQWM7a0JBSjFCLElBQUk7bUJBQUM7b0JBQ0YsSUFBSSxFQUFFLGVBQWU7b0JBQ3JCLFVBQVUsRUFBRSxJQUFJO2lCQUNuQiIsInNvdXJjZXNDb250ZW50IjpbIi8qIVxuICogQGxpY2Vuc2VcbiAqIENvcHlyaWdodCDCqSAyMDA1LTIwMjUgSHlsYW5kIFNvZnR3YXJlLCBJbmMuIGFuZCBpdHMgYWZmaWxpYXRlcy4gQWxsIHJpZ2h0cyByZXNlcnZlZC5cbiAqXG4gKiBMaWNlbnNlZCB1bmRlciB0aGUgQXBhY2hlIExpY2Vuc2UsIFZlcnNpb24gMi4wICh0aGUgXCJMaWNlbnNlXCIpO1xuICogeW91IG1heSBub3QgdXNlIHRoaXMgZmlsZSBleGNlcHQgaW4gY29tcGxpYW5jZSB3aXRoIHRoZSBMaWNlbnNlLlxuICogWW91IG1heSBvYnRhaW4gYSBjb3B5IG9mIHRoZSBMaWNlbnNlIGF0XG4gKlxuICogICAgIGh0dHA6Ly93d3cuYXBhY2hlLm9yZy9saWNlbnNlcy9MSUNFTlNFLTIuMFxuICpcbiAqIFVubGVzcyByZXF1aXJlZCBieSBhcHBsaWNhYmxlIGxhdyBvciBhZ3JlZWQgdG8gaW4gd3JpdGluZywgc29mdHdhcmVcbiAqIGRpc3RyaWJ1dGVkIHVuZGVyIHRoZSBMaWNlbnNlIGlzIGRpc3RyaWJ1dGVkIG9uIGFuIFwiQVMgSVNcIiBCQVNJUyxcbiAqIFdJVEhPVVQgV0FSUkFOVElFUyBPUiBDT05ESVRJT05TIE9GIEFOWSBLSU5ELCBlaXRoZXIgZXhwcmVzcyBvciBpbXBsaWVkLlxuICogU2VlIHRoZSBMaWNlbnNlIGZvciB0aGUgc3BlY2lmaWMgbGFuZ3VhZ2UgZ292ZXJuaW5nIHBlcm1pc3Npb25zIGFuZFxuICogbGltaXRhdGlvbnMgdW5kZXIgdGhlIExpY2Vuc2UuXG4gKi9cblxuaW1wb3J0IHsgUGlwZSwgUGlwZVRyYW5zZm9ybSB9IGZyb20gJ0Bhbmd1bGFyL2NvcmUnO1xuaW1wb3J0IHsgRm9ybUZpZWxkTW9kZWwgfSBmcm9tICcuLi9jb21wb25lbnRzL3dpZGdldHMvY29yZS9mb3JtLWZpZWxkLm1vZGVsJztcbmltcG9ydCB7IENvbnRhaW5lck1vZGVsIH0gZnJvbSAnLi4vY29tcG9uZW50cy93aWRnZXRzL2NvcmUvY29udGFpbmVyLm1vZGVsJztcbmltcG9ydCB7IHByZWRlZmluZWRUaGVtZSB9IGZyb20gJy4uL2NvbXBvbmVudHMvd2lkZ2V0cy9jb3JlL3ByZWRlZmluZWQtdGhlbWUnO1xuXG5AUGlwZSh7XG4gICAgbmFtZTogJ2FkZkZpZWxkU3R5bGUnLFxuICAgIHN0YW5kYWxvbmU6IHRydWVcbn0pXG5leHBvcnQgY2xhc3MgRmllbGRTdHlsZVBpcGUgaW1wbGVtZW50cyBQaXBlVHJhbnNmb3JtIHtcbiAgICB0cmFuc2Zvcm0oZmllbGQ6IEZvcm1GaWVsZE1vZGVsIHwgQ29udGFpbmVyTW9kZWwpOiBzdHJpbmcge1xuICAgICAgICBpZiAoIWZpZWxkLnN0eWxlKSB7XG4gICAgICAgICAgICByZXR1cm4gJyc7XG4gICAgICAgIH1cblxuICAgICAgICBjb25zdCB0aGVtZVN0eWxlID0gZmllbGQuZm9ybT8udGhlbWU/LndpZGdldHNbZmllbGQudHlwZV0/LltmaWVsZC5zdHlsZV07XG4gICAgICAgIGNvbnN0IHByZWRlZmluZWRUaGVtZVN0eWxlID0gcHJlZGVmaW5lZFRoZW1lLndpZGdldHNbZmllbGQudHlwZV0/LltmaWVsZC5zdHlsZV07XG4gICAgICAgIGNvbnN0IHN0eWxlcyA9ICh0aGVtZVN0eWxlIHx8IHByZWRlZmluZWRUaGVtZVN0eWxlKT8uc3R5bGVzO1xuXG4gICAgICAgIHJldHVybiBzdHlsZXMgPyB0aGlzLmZsYXR0ZW5TdHlsZXMoc3R5bGVzKSA6ICcnO1xuICAgIH1cblxuICAgIHByaXZhdGUgZmxhdHRlblN0eWxlcyhzdHlsZXM6IHsgW2tleTogc3RyaW5nXTogc3RyaW5nIH0pOiBzdHJpbmcge1xuICAgICAgICByZXR1cm4gT2JqZWN0LmVudHJpZXMoc3R5bGVzKVxuICAgICAgICAgICAgLm1hcCgoW2tleSwgdmFsdWVdKSA9PiBgJHtrZXl9OiR7dmFsdWV9O2ApXG4gICAgICAgICAgICAuam9pbignJyk7XG4gICAgfVxufVxuIl19

package/esm2022/lib/form/pipes/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 './field-style.pipe';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi9saWIvY29yZS9zcmMvbGliL2Zvcm0vcGlwZXMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7Ozs7Ozs7Ozs7Ozs7OztHQWVHO0FBRUgsY0FBYyxvQkFBb0IsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbIi8qIVxuICogQGxpY2Vuc2VcbiAqIENvcHlyaWdodCDCqSAyMDA1LTIwMjUgSHlsYW5kIFNvZnR3YXJlLCBJbmMuIGFuZCBpdHMgYWZmaWxpYXRlcy4gQWxsIHJpZ2h0cyByZXNlcnZlZC5cbiAqXG4gKiBMaWNlbnNlZCB1bmRlciB0aGUgQXBhY2hlIExpY2Vuc2UsIFZlcnNpb24gMi4wICh0aGUgXCJMaWNlbnNlXCIpO1xuICogeW91IG1heSBub3QgdXNlIHRoaXMgZmlsZSBleGNlcHQgaW4gY29tcGxpYW5jZSB3aXRoIHRoZSBMaWNlbnNlLlxuICogWW91IG1heSBvYnRhaW4gYSBjb3B5IG9mIHRoZSBMaWNlbnNlIGF0XG4gKlxuICogICAgIGh0dHA6Ly93d3cuYXBhY2hlLm9yZy9saWNlbnNlcy9MSUNFTlNFLTIuMFxuICpcbiAqIFVubGVzcyByZXF1aXJlZCBieSBhcHBsaWNhYmxlIGxhdyBvciBhZ3JlZWQgdG8gaW4gd3JpdGluZywgc29mdHdhcmVcbiAqIGRpc3RyaWJ1dGVkIHVuZGVyIHRoZSBMaWNlbnNlIGlzIGRpc3RyaWJ1dGVkIG9uIGFuIFwiQVMgSVNcIiBCQVNJUyxcbiAqIFdJVEhPVVQgV0FSUkFOVElFUyBPUiBDT05ESVRJT05TIE9GIEFOWSBLSU5ELCBlaXRoZXIgZXhwcmVzcyBvciBpbXBsaWVkLlxuICogU2VlIHRoZSBMaWNlbnNlIGZvciB0aGUgc3BlY2lmaWMgbGFuZ3VhZ2UgZ292ZXJuaW5nIHBlcm1pc3Npb25zIGFuZFxuICogbGltaXRhdGlvbnMgdW5kZXIgdGhlIExpY2Vuc2UuXG4gKi9cblxuZXhwb3J0ICogZnJvbSAnLi9maWVsZC1zdHlsZS5waXBlJztcbiJdfQ==

package/esm2022/lib/form/public-api.mjs

@@ -0,0 +1,35 @@
+/*!
+ * @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/form-field/form-field.component';
+export * from './components/form-base.component';
+export * from './components/inplace-form-input/inplace-form-input.component';
+export * from './components/form-custom-button.directive';
+export * from './components/form-renderer.component';
+export * from './components/widgets';
+export * from './components/middlewares/middleware';
+export * from './components/middlewares/decimal-middleware.service';
+export * from './components/helpers/buttons-visibility';
+export * from './services/form-rendering.service';
+export * from './services/form.service';
+export * from './services/form-validation-service.interface';
+export * from './services/widget-visibility.service';
+export * from './pipes';
+export * from './events';
+export * from './form-base.module';
+export * from './models/form-rules.model';
+export * from './models/task-process-variable.model';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHVibGljLWFwaS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uL2xpYi9jb3JlL3NyYy9saWIvZm9ybS9wdWJsaWMtYXBpLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOzs7Ozs7Ozs7Ozs7Ozs7R0FlRztBQUVILGNBQWMsOENBQThDLENBQUM7QUFDN0QsY0FBYyxrQ0FBa0MsQ0FBQztBQUNqRCxjQUFjLDhEQUE4RCxDQUFDO0FBQzdFLGNBQWMsMkNBQTJDLENBQUM7QUFDMUQsY0FBYyxzQ0FBc0MsQ0FBQztBQUNyRCxjQUFjLHNCQUFzQixDQUFDO0FBQ3JDLGNBQWMscUNBQXFDLENBQUM7QUFDcEQsY0FBYyxxREFBcUQsQ0FBQztBQUNwRSxjQUFjLHlDQUF5QyxDQUFDO0FBRXhELGNBQWMsbUNBQW1DLENBQUM7QUFDbEQsY0FBYyx5QkFBeUIsQ0FBQztBQUN4QyxjQUFjLDhDQUE4QyxDQUFDO0FBQzdELGNBQWMsc0NBQXNDLENBQUM7QUFFckQsY0FBYyxTQUFTLENBQUM7QUFFeEIsY0FBYyxVQUFVLENBQUM7QUFFekIsY0FBYyxvQkFBb0IsQ0FBQztBQUVuQyxjQUFjLDJCQUEyQixDQUFDO0FBQzFDLGNBQWMsc0NBQXNDLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyIvKiFcbiAqIEBsaWNlbnNlXG4gKiBDb3B5cmlnaHQgwqkgMjAwNS0yMDI1IEh5bGFuZCBTb2Z0d2FyZSwgSW5jLiBhbmQgaXRzIGFmZmlsaWF0ZXMuIEFsbCByaWdodHMgcmVzZXJ2ZWQuXG4gKlxuICogTGljZW5zZWQgdW5kZXIgdGhlIEFwYWNoZSBMaWNlbnNlLCBWZXJzaW9uIDIuMCAodGhlIFwiTGljZW5zZVwiKTtcbiAqIHlvdSBtYXkgbm90IHVzZSB0aGlzIGZpbGUgZXhjZXB0IGluIGNvbXBsaWFuY2Ugd2l0aCB0aGUgTGljZW5zZS5cbiAqIFlvdSBtYXkgb2J0YWluIGEgY29weSBvZiB0aGUgTGljZW5zZSBhdFxuICpcbiAqICAgICBodHRwOi8vd3d3LmFwYWNoZS5vcmcvbGljZW5zZXMvTElDRU5TRS0yLjBcbiAqXG4gKiBVbmxlc3MgcmVxdWlyZWQgYnkgYXBwbGljYWJsZSBsYXcgb3IgYWdyZWVkIHRvIGluIHdyaXRpbmcsIHNvZnR3YXJlXG4gKiBkaXN0cmlidXRlZCB1bmRlciB0aGUgTGljZW5zZSBpcyBkaXN0cmlidXRlZCBvbiBhbiBcIkFTIElTXCIgQkFTSVMsXG4gKiBXSVRIT1VUIFdBUlJBTlRJRVMgT1IgQ09ORElUSU9OUyBPRiBBTlkgS0lORCwgZWl0aGVyIGV4cHJlc3Mgb3IgaW1wbGllZC5cbiAqIFNlZSB0aGUgTGljZW5zZSBmb3IgdGhlIHNwZWNpZmljIGxhbmd1YWdlIGdvdmVybmluZyBwZXJtaXNzaW9ucyBhbmRcbiAqIGxpbWl0YXRpb25zIHVuZGVyIHRoZSBMaWNlbnNlLlxuICovXG5cbmV4cG9ydCAqIGZyb20gJy4vY29tcG9uZW50cy9mb3JtLWZpZWxkL2Zvcm0tZmllbGQuY29tcG9uZW50JztcbmV4cG9ydCAqIGZyb20gJy4vY29tcG9uZW50cy9mb3JtLWJhc2UuY29tcG9uZW50JztcbmV4cG9ydCAqIGZyb20gJy4vY29tcG9uZW50cy9pbnBsYWNlLWZvcm0taW5wdXQvaW5wbGFjZS1mb3JtLWlucHV0LmNvbXBvbmVudCc7XG5leHBvcnQgKiBmcm9tICcuL2NvbXBvbmVudHMvZm9ybS1jdXN0b20tYnV0dG9uLmRpcmVjdGl2ZSc7XG5leHBvcnQgKiBmcm9tICcuL2NvbXBvbmVudHMvZm9ybS1yZW5kZXJlci5jb21wb25lbnQnO1xuZXhwb3J0ICogZnJvbSAnLi9jb21wb25lbnRzL3dpZGdldHMnO1xuZXhwb3J0ICogZnJvbSAnLi9jb21wb25lbnRzL21pZGRsZXdhcmVzL21pZGRsZXdhcmUnO1xuZXhwb3J0ICogZnJvbSAnLi9jb21wb25lbnRzL21pZGRsZXdhcmVzL2RlY2ltYWwtbWlkZGxld2FyZS5zZXJ2aWNlJztcbmV4cG9ydCAqIGZyb20gJy4vY29tcG9uZW50cy9oZWxwZXJzL2J1dHRvbnMtdmlzaWJpbGl0eSc7XG5cbmV4cG9ydCAqIGZyb20gJy4vc2VydmljZXMvZm9ybS1yZW5kZXJpbmcuc2VydmljZSc7XG5leHBvcnQgKiBmcm9tICcuL3NlcnZpY2VzL2Zvcm0uc2VydmljZSc7XG5leHBvcnQgKiBmcm9tICcuL3NlcnZpY2VzL2Zvcm0tdmFsaWRhdGlvbi1zZXJ2aWNlLmludGVyZmFjZSc7XG5leHBvcnQgKiBmcm9tICcuL3NlcnZpY2VzL3dpZGdldC12aXNpYmlsaXR5LnNlcnZpY2UnO1xuXG5leHBvcnQgKiBmcm9tICcuL3BpcGVzJztcblxuZXhwb3J0ICogZnJvbSAnLi9ldmVudHMnO1xuXG5leHBvcnQgKiBmcm9tICcuL2Zvcm0tYmFzZS5tb2R1bGUnO1xuXG5leHBvcnQgKiBmcm9tICcuL21vZGVscy9mb3JtLXJ1bGVzLm1vZGVsJztcbmV4cG9ydCAqIGZyb20gJy4vbW9kZWxzL3Rhc2stcHJvY2Vzcy12YXJpYWJsZS5tb2RlbCc7XG4iXX0=

package/esm2022/lib/form/services/form-rendering.service.mjs

@@ -0,0 +1,53 @@
+/*!
+ * @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 { DynamicComponentMapper, DynamicComponentResolver } from '../../common/services/dynamic-component-mapper.service';
+import { Injectable } from '@angular/core';
+import * as widgets from '../components/widgets';
+import { FormFieldTypes } from '../components/widgets';
+import * as i0 from "@angular/core";
+/* eslint-disable id-blacklist */
+export class FormRenderingService extends DynamicComponentMapper {
+    constructor() {
+        super(...arguments);
+        this.defaultValue = widgets.UnknownWidgetComponent;
+        this.types = {
+            [FormFieldTypes.TEXT]: DynamicComponentResolver.fromType(widgets.TextWidgetComponent),
+            [FormFieldTypes.STRING]: DynamicComponentResolver.fromType(widgets.TextWidgetComponent),
+            [FormFieldTypes.INTEGER]: DynamicComponentResolver.fromType(widgets.NumberWidgetComponent),
+            [FormFieldTypes.DECIMAL]: DynamicComponentResolver.fromType(widgets.DecimalWidgetComponent),
+            [FormFieldTypes.MULTILINE_TEXT]: DynamicComponentResolver.fromType(widgets.MultilineTextWidgetComponentComponent),
+            [FormFieldTypes.BOOLEAN]: DynamicComponentResolver.fromType(widgets.CheckboxWidgetComponent),
+            [FormFieldTypes.DATE]: DynamicComponentResolver.fromType(widgets.DateWidgetComponent),
+            [FormFieldTypes.AMOUNT]: DynamicComponentResolver.fromType(widgets.AmountWidgetComponent),
+            [FormFieldTypes.HYPERLINK]: DynamicComponentResolver.fromType(widgets.HyperlinkWidgetComponent),
+            [FormFieldTypes.READONLY_TEXT]: DynamicComponentResolver.fromType(widgets.DisplayTextWidgetComponent),
+            [FormFieldTypes.JSON]: DynamicComponentResolver.fromType(widgets.JsonWidgetComponent),
+            [FormFieldTypes.DISPLAY_VALUE]: DynamicComponentResolver.fromType(widgets.TextWidgetComponent),
+            [FormFieldTypes.DATETIME]: DynamicComponentResolver.fromType(widgets.DateTimeWidgetComponent),
+            [FormFieldTypes.VIEWER]: DynamicComponentResolver.fromType(widgets.BaseViewerWidgetComponent)
+        };
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: FormRenderingService, deps: null, target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: FormRenderingService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: FormRenderingService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/form/services/form-validation-service.interface.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,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZm9ybS12YWxpZGF0aW9uLXNlcnZpY2UuaW50ZXJmYWNlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vLi4vbGliL2NvcmUvc3JjL2xpYi9mb3JtL3NlcnZpY2VzL2Zvcm0tdmFsaWRhdGlvbi1zZXJ2aWNlLmludGVyZmFjZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQTs7Ozs7Ozs7Ozs7Ozs7O0dBZUciLCJzb3VyY2VzQ29udGVudCI6WyIvKiFcbiAqIEBsaWNlbnNlXG4gKiBDb3B5cmlnaHQgwqkgMjAwNS0yMDI1IEh5bGFuZCBTb2Z0d2FyZSwgSW5jLiBhbmQgaXRzIGFmZmlsaWF0ZXMuIEFsbCByaWdodHMgcmVzZXJ2ZWQuXG4gKlxuICogTGljZW5zZWQgdW5kZXIgdGhlIEFwYWNoZSBMaWNlbnNlLCBWZXJzaW9uIDIuMCAodGhlIFwiTGljZW5zZVwiKTtcbiAqIHlvdSBtYXkgbm90IHVzZSB0aGlzIGZpbGUgZXhjZXB0IGluIGNvbXBsaWFuY2Ugd2l0aCB0aGUgTGljZW5zZS5cbiAqIFlvdSBtYXkgb2J0YWluIGEgY29weSBvZiB0aGUgTGljZW5zZSBhdFxuICpcbiAqICAgICBodHRwOi8vd3d3LmFwYWNoZS5vcmcvbGljZW5zZXMvTElDRU5TRS0yLjBcbiAqXG4gKiBVbmxlc3MgcmVxdWlyZWQgYnkgYXBwbGljYWJsZSBsYXcgb3IgYWdyZWVkIHRvIGluIHdyaXRpbmcsIHNvZnR3YXJlXG4gKiBkaXN0cmlidXRlZCB1bmRlciB0aGUgTGljZW5zZSBpcyBkaXN0cmlidXRlZCBvbiBhbiBcIkFTIElTXCIgQkFTSVMsXG4gKiBXSVRIT1VUIFdBUlJBTlRJRVMgT1IgQ09ORElUSU9OUyBPRiBBTlkgS0lORCwgZWl0aGVyIGV4cHJlc3Mgb3IgaW1wbGllZC5cbiAqIFNlZSB0aGUgTGljZW5zZSBmb3IgdGhlIHNwZWNpZmljIGxhbmd1YWdlIGdvdmVybmluZyBwZXJtaXNzaW9ucyBhbmRcbiAqIGxpbWl0YXRpb25zIHVuZGVyIHRoZSBMaWNlbnNlLlxuICovXG5cbmltcG9ydCB7IFN1YmplY3QgfSBmcm9tICdyeGpzJztcbmltcG9ydCB7IEZvcm1GaWVsZEV2ZW50IH0gZnJvbSAnLi4vZXZlbnRzL2Zvcm0tZmllbGQuZXZlbnQnO1xuaW1wb3J0IHsgVmFsaWRhdGVGb3JtRmllbGRFdmVudCB9IGZyb20gJy4uL2V2ZW50cy92YWxpZGF0ZS1mb3JtLWZpZWxkLmV2ZW50JztcbmltcG9ydCB7IFZhbGlkYXRlRm9ybUV2ZW50IH0gZnJvbSAnLi4vZXZlbnRzL3ZhbGlkYXRlLWZvcm0uZXZlbnQnO1xuXG5leHBvcnQgaW50ZXJmYWNlIEZvcm1WYWxpZGF0aW9uU2VydmljZSB7XG4gICAgZm9ybUZpZWxkVmFsdWVDaGFuZ2VkOiBTdWJqZWN0PEZvcm1GaWVsZEV2ZW50PjtcbiAgICB2YWxpZGF0ZUZvcm06IFN1YmplY3Q8VmFsaWRhdGVGb3JtRXZlbnQ+O1xuICAgIHZhbGlkYXRlRm9ybUZpZWxkOiBTdWJqZWN0PFZhbGlkYXRlRm9ybUZpZWxkRXZlbnQ+O1xufVxuIl19

package/esm2022/lib/form/services/form.service.mjs

@@ -0,0 +1,86 @@
+/*!
+ * @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 { Inject, Injectable, InjectionToken, Optional } from '@angular/core';
+import { Subject } from 'rxjs';
+import { FormModel } from '../components/widgets/core/form.model';
+import { FormOutcomeModel } from '../components/widgets/core/form-outcome.model';
+import * as i0 from "@angular/core";
+export const FORM_SERVICE_FIELD_VALIDATORS_TOKEN = new InjectionToken('FORM_SERVICE_FIELD_VALIDATORS_TOKEN');
+export class FormService {
+    constructor(injectedFieldValidators) {
+        this.formLoaded = new Subject();
+        this.formDataRefreshed = new Subject();
+        this.formFieldValueChanged = new Subject();
+        this.formEvents = new Subject();
+        this.taskCompleted = new Subject();
+        this.taskCompletedError = new Subject();
+        this.taskSaved = new Subject();
+        this.taskSavedError = new Subject();
+        this.formContentClicked = new Subject();
+        this.toggleFormSpinner = new Subject();
+        this.onFormVariableChanged = new Subject();
+        this.validateForm = new Subject();
+        this.validateFormField = new Subject();
+        this.validateDynamicTableRow = new Subject();
+        this.executeOutcome = new Subject();
+        this.updateFormValuesRequested = new Subject();
+        this.formRulesEvent = new Subject();
+        this.fieldValidators = injectedFieldValidators || [];
+    }
+    /**
+     * Parses JSON data to create a corresponding Form model.
+     *
+     * @param json JSON to create the form
+     * @param data Values for the form fields
+     * @param readOnly Should the form fields be read-only?
+     * @param fixedSpace use fixed space
+     * @returns Form model created from input data
+     */
+    parseForm(json, data, readOnly = false, fixedSpace) {
+        if (json) {
+            const form = new FormModel(json, data, readOnly, this, fixedSpace, this.fieldValidators);
+            if (!json.fields) {
+                form.outcomes = [
+                    new FormOutcomeModel(form, {
+                        id: '$save',
+                        name: FormOutcomeModel.SAVE_ACTION,
+                        isSystem: true
+                    })
+                ];
+            }
+            return form;
+        }
+        return null;
+    }
+    getPreviewState() {
+        return false;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: FormService, deps: [{ token: FORM_SERVICE_FIELD_VALIDATORS_TOKEN, optional: true }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: FormService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: FormService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: () => [{ type: undefined, decorators: [{
+                    type: Optional
+                }, {
+                    type: Inject,
+                    args: [FORM_SERVICE_FIELD_VALIDATORS_TOKEN]
+                }] }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"form.service.js","sourceRoot":"","sources":["../../../../../../../lib/core/src/lib/form/services/form.service.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAEH,OAAO,EAAE,MAAM,EAAE,UAAU,EAAE,cAAc,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAC;AAC7E,OAAO,EAAE,OAAO,EAAE,MAAM,MAAM,CAAC;AAI/B,OAAO,EAAE,SAAS,EAAE,MAAM,uCAAuC,CAAC;AAClE,OAAO,EAAE,gBAAgB,EAAE,MAAM,+CAA+C,CAAC;;AAWjF,MAAM,CAAC,MAAM,mCAAmC,GAAG,IAAI,cAAc,CAAuB,qCAAqC,CAAC,CAAC;AAKnI,MAAM,OAAO,WAAW;IAyBpB,YAAqE,uBAA8C;QAvBnH,eAAU,GAAG,IAAI,OAAO,EAAa,CAAC;QACtC,sBAAiB,GAAG,IAAI,OAAO,EAAa,CAAC;QAC7C,0BAAqB,GAAG,IAAI,OAAO,EAAkB,CAAC;QACtD,eAAU,GAAG,IAAI,OAAO,EAAS,CAAC;QAClC,kBAAa,GAAG,IAAI,OAAO,EAAa,CAAC;QACzC,uBAAkB,GAAG,IAAI,OAAO,EAAkB,CAAC;QACnD,cAAS,GAAG,IAAI,OAAO,EAAa,CAAC;QACrC,mBAAc,GAAG,IAAI,OAAO,EAAkB,CAAC;QAC/C,uBAAkB,GAAG,IAAI,OAAO,EAAoB,CAAC;QACrD,sBAAiB,GAAG,IAAI,OAAO,EAAoB,CAAC;QAEpD,0BAAqB,GAAG,IAAI,OAAO,EAAyC,CAAC;QAE7E,iBAAY,GAAG,IAAI,OAAO,EAAqB,CAAC;QAChD,sBAAiB,GAAG,IAAI,OAAO,EAA0B,CAAC;QAC1D,4BAAuB,GAAG,IAAI,OAAO,EAAkB,CAAC;QAExD,mBAAc,GAAG,IAAI,OAAO,EAAoB,CAAC;QAEjD,8BAAyB,GAAG,IAAI,OAAO,EAAc,CAAC;QAEtD,mBAAc,GAAG,IAAI,OAAO,EAAkB,CAAC;QAG3C,IAAI,CAAC,eAAe,GAAG,uBAAuB,IAAI,EAAE,CAAC;IACzD,CAAC;IAED;;;;;;;;OAQG;IACH,SAAS,CAAC,IAAS,EAAE,IAAiB,EAAE,WAAoB,KAAK,EAAE,UAAoB;QACnF,IAAI,IAAI,EAAE,CAAC;YACP,MAAM,IAAI,GAAG,IAAI,SAAS,CAAC,IAAI,EAAE,IAAI,EAAE,QAAQ,EAAE,IAAI,EAAE,UAAU,EAAE,IAAI,CAAC,eAAe,CAAC,CAAC;YACzF,IAAI,CAAC,IAAI,CAAC,MAAM,EAAE,CAAC;gBACf,IAAI,CAAC,QAAQ,GAAG;oBACZ,IAAI,gBAAgB,CAAC,IAAI,EAAE;wBACvB,EAAE,EAAE,OAAO;wBACX,IAAI,EAAE,gBAAgB,CAAC,WAAW;wBAClC,QAAQ,EAAE,IAAI;qBACjB,CAAC;iBACL,CAAC;YACN,CAAC;YACD,OAAO,IAAI,CAAC;QAChB,CAAC;QACD,OAAO,IAAI,CAAC;IAChB,CAAC;IAED,eAAe;QACX,OAAO,KAAK,CAAC;IACjB,CAAC;+GAzDQ,WAAW,kBAyBY,mCAAmC;mHAzB1D,WAAW,cAFR,MAAM;;4FAET,WAAW;kBAHvB,UAAU;mBAAC;oBACR,UAAU,EAAE,MAAM;iBACrB;;0BA0BgB,QAAQ;;0BAAI,MAAM;2BAAC,mCAAmC","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 { Inject, Injectable, InjectionToken, Optional } from '@angular/core';\nimport { Subject } from 'rxjs';\nimport { ContentLinkModel } from '../components/widgets/core/content-link.model';\nimport { FormOutcomeEvent } from '../components/widgets/core/form-outcome-event.model';\nimport { FormValues } from '../components/widgets/core/form-values';\nimport { FormModel } from '../components/widgets/core/form.model';\nimport { FormOutcomeModel } from '../components/widgets/core/form-outcome.model';\nimport { FormEvent } from '../events/form.event';\nimport { FormFieldEvent } from '../events/form-field.event';\nimport { FormErrorEvent } from '../events/form-error.event';\nimport { ValidateFormEvent } from '../events/validate-form.event';\nimport { ValidateFormFieldEvent } from '../events/validate-form-field.event';\nimport { FormValidationService } from './form-validation-service.interface';\nimport { FormRulesEvent } from '../events/form-rules.event';\nimport { FormSpinnerEvent } from '../events';\nimport { FormFieldModel, FormFieldValidator } from '../components/widgets';\n\nexport const FORM_SERVICE_FIELD_VALIDATORS_TOKEN = new InjectionToken<FormFieldValidator[]>('FORM_SERVICE_FIELD_VALIDATORS_TOKEN');\n\n@Injectable({\n    providedIn: 'root'\n})\nexport class FormService implements FormValidationService {\n    private fieldValidators: FormFieldValidator[];\n    formLoaded = new Subject<FormEvent>();\n    formDataRefreshed = new Subject<FormEvent>();\n    formFieldValueChanged = new Subject<FormFieldEvent>();\n    formEvents = new Subject<Event>();\n    taskCompleted = new Subject<FormEvent>();\n    taskCompletedError = new Subject<FormErrorEvent>();\n    taskSaved = new Subject<FormEvent>();\n    taskSavedError = new Subject<FormErrorEvent>();\n    formContentClicked = new Subject<ContentLinkModel>();\n    toggleFormSpinner = new Subject<FormSpinnerEvent>();\n\n    onFormVariableChanged = new Subject<{ field: FormFieldModel; data?: any }>();\n\n    validateForm = new Subject<ValidateFormEvent>();\n    validateFormField = new Subject<ValidateFormFieldEvent>();\n    validateDynamicTableRow = new Subject<FormFieldEvent>();\n\n    executeOutcome = new Subject<FormOutcomeEvent>();\n\n    updateFormValuesRequested = new Subject<FormValues>();\n\n    formRulesEvent = new Subject<FormRulesEvent>();\n\n    constructor(@Optional() @Inject(FORM_SERVICE_FIELD_VALIDATORS_TOKEN) injectedFieldValidators?: FormFieldValidator[]) {\n        this.fieldValidators = injectedFieldValidators || [];\n    }\n\n    /**\n     * Parses JSON data to create a corresponding Form model.\n     *\n     * @param json JSON to create the form\n     * @param data Values for the form fields\n     * @param readOnly Should the form fields be read-only?\n     * @param fixedSpace use fixed space\n     * @returns Form model created from input data\n     */\n    parseForm(json: any, data?: FormValues, readOnly: boolean = false, fixedSpace?: boolean): FormModel {\n        if (json) {\n            const form = new FormModel(json, data, readOnly, this, fixedSpace, this.fieldValidators);\n            if (!json.fields) {\n                form.outcomes = [\n                    new FormOutcomeModel(form, {\n                        id: '$save',\n                        name: FormOutcomeModel.SAVE_ACTION,\n                        isSystem: true\n                    })\n                ];\n            }\n            return form;\n        }\n        return null;\n    }\n\n    getPreviewState(): boolean {\n        return false;\n    }\n}\n"]}