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

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

@@ -0,0 +1,49 @@
+/*!
+ * @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 * from './form-field-metadata';
+export * from './form-values';
+export * from './form-field-types';
+export * from './form-field-option';
+export * from './form-field-templates';
+export * from './form-widget.model';
+export * from './form-field.model';
+export * from './form.model';
+export * from './process-form-model.interface';
+export * from './container.model';
+export * from './container-column.model';
+export * from './tab.model';
+export * from './form-outcome.model';
+export * from './form-outcome-event.model';
+export * from './form-field-validator';
+export * from './content-link.model';
+export * from './error-message.model';
+export * from './external-content';
+export * from './external-content-link';
+export * from './group.model';
+export * from './form-variable.model';
+export * from './process-variable.model';
+export * from './upload-widget-content-link.model';
+export * from './form-field-file-source';
+export * from './form-field-rule';
+export * from './form-field-utils';
+export * from './form-field-variable-options';
+export * from './widget-schema.model';
+export * from './theme.model';
+export * from './predefined-theme';
+export * from './displayable-cm-properties.model';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi9saWIvY29yZS9zcmMvbGliL2Zvcm0vY29tcG9uZW50cy93aWRnZXRzL2NvcmUvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7Ozs7Ozs7Ozs7Ozs7OztHQWVHO0FBRUgsdURBQXVEO0FBRXZELGNBQWMsdUJBQXVCLENBQUM7QUFDdEMsY0FBYyxlQUFlLENBQUM7QUFDOUIsY0FBYyxvQkFBb0IsQ0FBQztBQUNuQyxjQUFjLHFCQUFxQixDQUFDO0FBQ3BDLGNBQWMsd0JBQXdCLENBQUM7QUFDdkMsY0FBYyxxQkFBcUIsQ0FBQztBQUNwQyxjQUFjLG9CQUFvQixDQUFDO0FBQ25DLGNBQWMsY0FBYyxDQUFDO0FBQzdCLGNBQWMsZ0NBQWdDLENBQUM7QUFDL0MsY0FBYyxtQkFBbUIsQ0FBQztBQUNsQyxjQUFjLDBCQUEwQixDQUFDO0FBQ3pDLGNBQWMsYUFBYSxDQUFDO0FBQzVCLGNBQWMsc0JBQXNCLENBQUM7QUFDckMsY0FBYyw0QkFBNEIsQ0FBQztBQUMzQyxjQUFjLHdCQUF3QixDQUFDO0FBQ3ZDLGNBQWMsc0JBQXNCLENBQUM7QUFDckMsY0FBYyx1QkFBdUIsQ0FBQztBQUN0QyxjQUFjLG9CQUFvQixDQUFDO0FBQ25DLGNBQWMseUJBQXlCLENBQUM7QUFDeEMsY0FBYyxlQUFlLENBQUM7QUFDOUIsY0FBYyx1QkFBdUIsQ0FBQztBQUN0QyxjQUFjLDBCQUEwQixDQUFDO0FBQ3pDLGNBQWMsb0NBQW9DLENBQUM7QUFDbkQsY0FBYywwQkFBMEIsQ0FBQztBQUN6QyxjQUFjLG1CQUFtQixDQUFDO0FBQ2xDLGNBQWMsb0JBQW9CLENBQUM7QUFDbkMsY0FBYywrQkFBK0IsQ0FBQztBQUM5QyxjQUFjLHVCQUF1QixDQUFDO0FBQ3RDLGNBQWMsZUFBZSxDQUFDO0FBQzlCLGNBQWMsb0JBQW9CLENBQUM7QUFDbkMsY0FBYyxtQ0FBbUMsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbIi8qIVxuICogQGxpY2Vuc2VcbiAqIENvcHlyaWdodCDCqSAyMDA1LTIwMjUgSHlsYW5kIFNvZnR3YXJlLCBJbmMuIGFuZCBpdHMgYWZmaWxpYXRlcy4gQWxsIHJpZ2h0cyByZXNlcnZlZC5cbiAqXG4gKiBMaWNlbnNlZCB1bmRlciB0aGUgQXBhY2hlIExpY2Vuc2UsIFZlcnNpb24gMi4wICh0aGUgXCJMaWNlbnNlXCIpO1xuICogeW91IG1heSBub3QgdXNlIHRoaXMgZmlsZSBleGNlcHQgaW4gY29tcGxpYW5jZSB3aXRoIHRoZSBMaWNlbnNlLlxuICogWW91IG1heSBvYnRhaW4gYSBjb3B5IG9mIHRoZSBMaWNlbnNlIGF0XG4gKlxuICogICAgIGh0dHA6Ly93d3cuYXBhY2hlLm9yZy9saWNlbnNlcy9MSUNFTlNFLTIuMFxuICpcbiAqIFVubGVzcyByZXF1aXJlZCBieSBhcHBsaWNhYmxlIGxhdyBvciBhZ3JlZWQgdG8gaW4gd3JpdGluZywgc29mdHdhcmVcbiAqIGRpc3RyaWJ1dGVkIHVuZGVyIHRoZSBMaWNlbnNlIGlzIGRpc3RyaWJ1dGVkIG9uIGFuIFwiQVMgSVNcIiBCQVNJUyxcbiAqIFdJVEhPVVQgV0FSUkFOVElFUyBPUiBDT05ESVRJT05TIE9GIEFOWSBLSU5ELCBlaXRoZXIgZXhwcmVzcyBvciBpbXBsaWVkLlxuICogU2VlIHRoZSBMaWNlbnNlIGZvciB0aGUgc3BlY2lmaWMgbGFuZ3VhZ2UgZ292ZXJuaW5nIHBlcm1pc3Npb25zIGFuZFxuICogbGltaXRhdGlvbnMgdW5kZXIgdGhlIExpY2Vuc2UuXG4gKi9cblxuLyogZXNsaW50LWRpc2FibGUgQGFuZ3VsYXItZXNsaW50L2NvbXBvbmVudC1zZWxlY3RvciAqL1xuXG5leHBvcnQgKiBmcm9tICcuL2Zvcm0tZmllbGQtbWV0YWRhdGEnO1xuZXhwb3J0ICogZnJvbSAnLi9mb3JtLXZhbHVlcyc7XG5leHBvcnQgKiBmcm9tICcuL2Zvcm0tZmllbGQtdHlwZXMnO1xuZXhwb3J0ICogZnJvbSAnLi9mb3JtLWZpZWxkLW9wdGlvbic7XG5leHBvcnQgKiBmcm9tICcuL2Zvcm0tZmllbGQtdGVtcGxhdGVzJztcbmV4cG9ydCAqIGZyb20gJy4vZm9ybS13aWRnZXQubW9kZWwnO1xuZXhwb3J0ICogZnJvbSAnLi9mb3JtLWZpZWxkLm1vZGVsJztcbmV4cG9ydCAqIGZyb20gJy4vZm9ybS5tb2RlbCc7XG5leHBvcnQgKiBmcm9tICcuL3Byb2Nlc3MtZm9ybS1tb2RlbC5pbnRlcmZhY2UnO1xuZXhwb3J0ICogZnJvbSAnLi9jb250YWluZXIubW9kZWwnO1xuZXhwb3J0ICogZnJvbSAnLi9jb250YWluZXItY29sdW1uLm1vZGVsJztcbmV4cG9ydCAqIGZyb20gJy4vdGFiLm1vZGVsJztcbmV4cG9ydCAqIGZyb20gJy4vZm9ybS1vdXRjb21lLm1vZGVsJztcbmV4cG9ydCAqIGZyb20gJy4vZm9ybS1vdXRjb21lLWV2ZW50Lm1vZGVsJztcbmV4cG9ydCAqIGZyb20gJy4vZm9ybS1maWVsZC12YWxpZGF0b3InO1xuZXhwb3J0ICogZnJvbSAnLi9jb250ZW50LWxpbmsubW9kZWwnO1xuZXhwb3J0ICogZnJvbSAnLi9lcnJvci1tZXNzYWdlLm1vZGVsJztcbmV4cG9ydCAqIGZyb20gJy4vZXh0ZXJuYWwtY29udGVudCc7XG5leHBvcnQgKiBmcm9tICcuL2V4dGVybmFsLWNvbnRlbnQtbGluayc7XG5leHBvcnQgKiBmcm9tICcuL2dyb3VwLm1vZGVsJztcbmV4cG9ydCAqIGZyb20gJy4vZm9ybS12YXJpYWJsZS5tb2RlbCc7XG5leHBvcnQgKiBmcm9tICcuL3Byb2Nlc3MtdmFyaWFibGUubW9kZWwnO1xuZXhwb3J0ICogZnJvbSAnLi91cGxvYWQtd2lkZ2V0LWNvbnRlbnQtbGluay5tb2RlbCc7XG5leHBvcnQgKiBmcm9tICcuL2Zvcm0tZmllbGQtZmlsZS1zb3VyY2UnO1xuZXhwb3J0ICogZnJvbSAnLi9mb3JtLWZpZWxkLXJ1bGUnO1xuZXhwb3J0ICogZnJvbSAnLi9mb3JtLWZpZWxkLXV0aWxzJztcbmV4cG9ydCAqIGZyb20gJy4vZm9ybS1maWVsZC12YXJpYWJsZS1vcHRpb25zJztcbmV4cG9ydCAqIGZyb20gJy4vd2lkZ2V0LXNjaGVtYS5tb2RlbCc7XG5leHBvcnQgKiBmcm9tICcuL3RoZW1lLm1vZGVsJztcbmV4cG9ydCAqIGZyb20gJy4vcHJlZGVmaW5lZC10aGVtZSc7XG5leHBvcnQgKiBmcm9tICcuL2Rpc3BsYXlhYmxlLWNtLXByb3BlcnRpZXMubW9kZWwnO1xuIl19

package/esm2022/lib/form/components/widgets/core/predefined-theme.mjs

@@ -0,0 +1,115 @@
+/*!
+ * @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 const predefinedTheme = {
+    widgets: {
+        'readonly-text': {
+            normal: {
+                name: 'FORM.FIELD_STYLE.PREDEFINED.READONLY_TEXT.NORMAL',
+                styles: {
+                    '--adf-readonly-text-font-size': '16px',
+                    '--adf-readonly-text-font-weight': 'normal',
+                    '--adf-readonly-text-color': 'inherit'
+                }
+            },
+            strong: {
+                name: 'FORM.FIELD_STYLE.PREDEFINED.READONLY_TEXT.STRONG',
+                styles: {
+                    '--adf-readonly-text-font-size': '16px',
+                    '--adf-readonly-text-font-weight': 'bold',
+                    '--adf-readonly-text-color': 'inherit'
+                }
+            },
+            heading: {
+                name: 'FORM.FIELD_STYLE.PREDEFINED.READONLY_TEXT.HEADING',
+                styles: {
+                    '--adf-readonly-text-font-size': '20px',
+                    '--adf-readonly-text-font-weight': 'normal',
+                    '--adf-readonly-text-color': 'inherit'
+                }
+            },
+            title: {
+                name: 'FORM.FIELD_STYLE.PREDEFINED.READONLY_TEXT.TITLE',
+                styles: {
+                    '--adf-readonly-text-font-size': '24px',
+                    '--adf-readonly-text-font-weight': 'normal',
+                    '--adf-readonly-text-color': 'inherit'
+                }
+            },
+            annotation: {
+                name: 'FORM.FIELD_STYLE.PREDEFINED.READONLY_TEXT.ANNOTATION',
+                styles: {
+                    '--adf-readonly-text-font-size': '12px',
+                    '--adf-readonly-text-font-weight': 'normal',
+                    '--adf-readonly-text-color': 'inherit'
+                }
+            }
+        },
+        group: {
+            normal: {
+                name: 'FORM.FIELD_STYLE.PREDEFINED.HEADER.NORMAL',
+                styles: {
+                    '--adf-header-font-size': '16px',
+                    '--adf-header-font-weight': 'normal',
+                    '--adf-header-color': 'inherit'
+                }
+            },
+            heading: {
+                name: 'FORM.FIELD_STYLE.PREDEFINED.HEADER.HEADING',
+                styles: {
+                    '--adf-header-font-size': '20px',
+                    '--adf-header-font-weight': 'normal',
+                    '--adf-header-color': 'inherit'
+                }
+            },
+            title: {
+                name: 'FORM.FIELD_STYLE.PREDEFINED.HEADER.TITLE',
+                styles: {
+                    '--adf-header-font-size': '24px',
+                    '--adf-header-font-weight': 'normal',
+                    '--adf-header-color': 'inherit'
+                }
+            }
+        },
+        'radio-buttons': {
+            normal: {
+                name: 'FORM.FIELD_STYLE.PREDEFINED.RADIO_BUTTONS.NORMAL',
+                styles: {
+                    '--adf-radio-buttons-font-size': '16px',
+                    '--adf-radio-buttons-font-weight': 'normal',
+                    '--adf-radio-buttons-color': 'inherit'
+                }
+            },
+            strong: {
+                name: 'FORM.FIELD_STYLE.PREDEFINED.RADIO_BUTTONS.STRONG',
+                styles: {
+                    '--adf-radio-buttons-font-size': '16px',
+                    '--adf-radio-buttons-font-weight': 'bold',
+                    '--adf-radio-buttons-color': 'inherit'
+                }
+            },
+            heading: {
+                name: 'FORM.FIELD_STYLE.PREDEFINED.RADIO_BUTTONS.HEADING',
+                styles: {
+                    '--adf-radio-buttons-font-size': '20px',
+                    '--adf-radio-buttons-font-weight': 'normal',
+                    '--adf-radio-buttons-color': 'inherit'
+                }
+            }
+        }
+    }
+};
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"predefined-theme.js","sourceRoot":"","sources":["../../../../../../../../../lib/core/src/lib/form/components/widgets/core/predefined-theme.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAIH,MAAM,CAAC,MAAM,eAAe,GAAyB;IACjD,OAAO,EAAE;QACL,eAAe,EAAE;YACb,MAAM,EAAE;gBACJ,IAAI,EAAE,kDAAkD;gBACxD,MAAM,EAAE;oBACJ,+BAA+B,EAAE,MAAM;oBACvC,iCAAiC,EAAE,QAAQ;oBAC3C,2BAA2B,EAAE,SAAS;iBACzC;aACJ;YACD,MAAM,EAAE;gBACJ,IAAI,EAAE,kDAAkD;gBACxD,MAAM,EAAE;oBACJ,+BAA+B,EAAE,MAAM;oBACvC,iCAAiC,EAAE,MAAM;oBACzC,2BAA2B,EAAE,SAAS;iBACzC;aACJ;YACD,OAAO,EAAE;gBACL,IAAI,EAAE,mDAAmD;gBACzD,MAAM,EAAE;oBACJ,+BAA+B,EAAE,MAAM;oBACvC,iCAAiC,EAAE,QAAQ;oBAC3C,2BAA2B,EAAE,SAAS;iBACzC;aACJ;YACD,KAAK,EAAE;gBACH,IAAI,EAAE,iDAAiD;gBACvD,MAAM,EAAE;oBACJ,+BAA+B,EAAE,MAAM;oBACvC,iCAAiC,EAAE,QAAQ;oBAC3C,2BAA2B,EAAE,SAAS;iBACzC;aACJ;YACD,UAAU,EAAE;gBACR,IAAI,EAAE,sDAAsD;gBAC5D,MAAM,EAAE;oBACJ,+BAA+B,EAAE,MAAM;oBACvC,iCAAiC,EAAE,QAAQ;oBAC3C,2BAA2B,EAAE,SAAS;iBACzC;aACJ;SACJ;QACD,KAAK,EAAE;YACH,MAAM,EAAE;gBACJ,IAAI,EAAE,2CAA2C;gBACjD,MAAM,EAAE;oBACJ,wBAAwB,EAAE,MAAM;oBAChC,0BAA0B,EAAE,QAAQ;oBACpC,oBAAoB,EAAE,SAAS;iBAClC;aACJ;YACD,OAAO,EAAE;gBACL,IAAI,EAAE,4CAA4C;gBAClD,MAAM,EAAE;oBACJ,wBAAwB,EAAE,MAAM;oBAChC,0BAA0B,EAAE,QAAQ;oBACpC,oBAAoB,EAAE,SAAS;iBAClC;aACJ;YACD,KAAK,EAAE;gBACH,IAAI,EAAE,0CAA0C;gBAChD,MAAM,EAAE;oBACJ,wBAAwB,EAAE,MAAM;oBAChC,0BAA0B,EAAE,QAAQ;oBACpC,oBAAoB,EAAE,SAAS;iBAClC;aACJ;SACJ;QACD,eAAe,EAAE;YACb,MAAM,EAAE;gBACJ,IAAI,EAAE,kDAAkD;gBACxD,MAAM,EAAE;oBACJ,+BAA+B,EAAE,MAAM;oBACvC,iCAAiC,EAAE,QAAQ;oBAC3C,2BAA2B,EAAE,SAAS;iBACzC;aACJ;YACD,MAAM,EAAE;gBACJ,IAAI,EAAE,kDAAkD;gBACxD,MAAM,EAAE;oBACJ,+BAA+B,EAAE,MAAM;oBACvC,iCAAiC,EAAE,MAAM;oBACzC,2BAA2B,EAAE,SAAS;iBACzC;aACJ;YACD,OAAO,EAAE;gBACL,IAAI,EAAE,mDAAmD;gBACzD,MAAM,EAAE;oBACJ,+BAA+B,EAAE,MAAM;oBACvC,iCAAiC,EAAE,QAAQ;oBAC3C,2BAA2B,EAAE,SAAS;iBACzC;aACJ;SACJ;KACJ;CACJ,CAAC","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 { PredefinedThemeModel } from './theme.model';\n\nexport const predefinedTheme: PredefinedThemeModel = {\n    widgets: {\n        'readonly-text': {\n            normal: {\n                name: 'FORM.FIELD_STYLE.PREDEFINED.READONLY_TEXT.NORMAL',\n                styles: {\n                    '--adf-readonly-text-font-size': '16px',\n                    '--adf-readonly-text-font-weight': 'normal',\n                    '--adf-readonly-text-color': 'inherit'\n                }\n            },\n            strong: {\n                name: 'FORM.FIELD_STYLE.PREDEFINED.READONLY_TEXT.STRONG',\n                styles: {\n                    '--adf-readonly-text-font-size': '16px',\n                    '--adf-readonly-text-font-weight': 'bold',\n                    '--adf-readonly-text-color': 'inherit'\n                }\n            },\n            heading: {\n                name: 'FORM.FIELD_STYLE.PREDEFINED.READONLY_TEXT.HEADING',\n                styles: {\n                    '--adf-readonly-text-font-size': '20px',\n                    '--adf-readonly-text-font-weight': 'normal',\n                    '--adf-readonly-text-color': 'inherit'\n                }\n            },\n            title: {\n                name: 'FORM.FIELD_STYLE.PREDEFINED.READONLY_TEXT.TITLE',\n                styles: {\n                    '--adf-readonly-text-font-size': '24px',\n                    '--adf-readonly-text-font-weight': 'normal',\n                    '--adf-readonly-text-color': 'inherit'\n                }\n            },\n            annotation: {\n                name: 'FORM.FIELD_STYLE.PREDEFINED.READONLY_TEXT.ANNOTATION',\n                styles: {\n                    '--adf-readonly-text-font-size': '12px',\n                    '--adf-readonly-text-font-weight': 'normal',\n                    '--adf-readonly-text-color': 'inherit'\n                }\n            }\n        },\n        group: {\n            normal: {\n                name: 'FORM.FIELD_STYLE.PREDEFINED.HEADER.NORMAL',\n                styles: {\n                    '--adf-header-font-size': '16px',\n                    '--adf-header-font-weight': 'normal',\n                    '--adf-header-color': 'inherit'\n                }\n            },\n            heading: {\n                name: 'FORM.FIELD_STYLE.PREDEFINED.HEADER.HEADING',\n                styles: {\n                    '--adf-header-font-size': '20px',\n                    '--adf-header-font-weight': 'normal',\n                    '--adf-header-color': 'inherit'\n                }\n            },\n            title: {\n                name: 'FORM.FIELD_STYLE.PREDEFINED.HEADER.TITLE',\n                styles: {\n                    '--adf-header-font-size': '24px',\n                    '--adf-header-font-weight': 'normal',\n                    '--adf-header-color': 'inherit'\n                }\n            }\n        },\n        'radio-buttons': {\n            normal: {\n                name: 'FORM.FIELD_STYLE.PREDEFINED.RADIO_BUTTONS.NORMAL',\n                styles: {\n                    '--adf-radio-buttons-font-size': '16px',\n                    '--adf-radio-buttons-font-weight': 'normal',\n                    '--adf-radio-buttons-color': 'inherit'\n                }\n            },\n            strong: {\n                name: 'FORM.FIELD_STYLE.PREDEFINED.RADIO_BUTTONS.STRONG',\n                styles: {\n                    '--adf-radio-buttons-font-size': '16px',\n                    '--adf-radio-buttons-font-weight': 'bold',\n                    '--adf-radio-buttons-color': 'inherit'\n                }\n            },\n            heading: {\n                name: 'FORM.FIELD_STYLE.PREDEFINED.RADIO_BUTTONS.HEADING',\n                styles: {\n                    '--adf-radio-buttons-font-size': '20px',\n                    '--adf-radio-buttons-font-weight': 'normal',\n                    '--adf-radio-buttons-color': 'inherit'\n                }\n            }\n        }\n    }\n};\n"]}

package/esm2022/lib/form/components/widgets/core/process-form-model.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,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHJvY2Vzcy1mb3JtLW1vZGVsLmludGVyZmFjZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uLy4uLy4uLy4uL2xpYi9jb3JlL3NyYy9saWIvZm9ybS9jb21wb25lbnRzL3dpZGdldHMvY29yZS9wcm9jZXNzLWZvcm0tbW9kZWwuaW50ZXJmYWNlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOzs7Ozs7Ozs7Ozs7Ozs7R0FlRyIsInNvdXJjZXNDb250ZW50IjpbIi8qIVxuICogQGxpY2Vuc2VcbiAqIENvcHlyaWdodCDCqSAyMDA1LTIwMjUgSHlsYW5kIFNvZnR3YXJlLCBJbmMuIGFuZCBpdHMgYWZmaWxpYXRlcy4gQWxsIHJpZ2h0cyByZXNlcnZlZC5cbiAqXG4gKiBMaWNlbnNlZCB1bmRlciB0aGUgQXBhY2hlIExpY2Vuc2UsIFZlcnNpb24gMi4wICh0aGUgXCJMaWNlbnNlXCIpO1xuICogeW91IG1heSBub3QgdXNlIHRoaXMgZmlsZSBleGNlcHQgaW4gY29tcGxpYW5jZSB3aXRoIHRoZSBMaWNlbnNlLlxuICogWW91IG1heSBvYnRhaW4gYSBjb3B5IG9mIHRoZSBMaWNlbnNlIGF0XG4gKlxuICogICAgIGh0dHA6Ly93d3cuYXBhY2hlLm9yZy9saWNlbnNlcy9MSUNFTlNFLTIuMFxuICpcbiAqIFVubGVzcyByZXF1aXJlZCBieSBhcHBsaWNhYmxlIGxhdyBvciBhZ3JlZWQgdG8gaW4gd3JpdGluZywgc29mdHdhcmVcbiAqIGRpc3RyaWJ1dGVkIHVuZGVyIHRoZSBMaWNlbnNlIGlzIGRpc3RyaWJ1dGVkIG9uIGFuIFwiQVMgSVNcIiBCQVNJUyxcbiAqIFdJVEhPVVQgV0FSUkFOVElFUyBPUiBDT05ESVRJT05TIE9GIEFOWSBLSU5ELCBlaXRoZXIgZXhwcmVzcyBvciBpbXBsaWVkLlxuICogU2VlIHRoZSBMaWNlbnNlIGZvciB0aGUgc3BlY2lmaWMgbGFuZ3VhZ2UgZ292ZXJuaW5nIHBlcm1pc3Npb25zIGFuZFxuICogbGltaXRhdGlvbnMgdW5kZXIgdGhlIExpY2Vuc2UuXG4gKi9cblxuZXhwb3J0IGludGVyZmFjZSBQcm9jZXNzRm9ybU1vZGVsIHtcbiAgICBnZXRQcm9jZXNzVmFyaWFibGVWYWx1ZShuYW1lOiBzdHJpbmcpOiBhbnk7XG59XG4iXX0=

package/esm2022/lib/form/components/widgets/core/process-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,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHJvY2Vzcy12YXJpYWJsZS5tb2RlbC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uLy4uLy4uLy4uL2xpYi9jb3JlL3NyYy9saWIvZm9ybS9jb21wb25lbnRzL3dpZGdldHMvY29yZS9wcm9jZXNzLXZhcmlhYmxlLm1vZGVsLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOzs7Ozs7Ozs7Ozs7Ozs7R0FlRyIsInNvdXJjZXNDb250ZW50IjpbIi8qIVxuICogQGxpY2Vuc2VcbiAqIENvcHlyaWdodCDCqSAyMDA1LTIwMjUgSHlsYW5kIFNvZnR3YXJlLCBJbmMuIGFuZCBpdHMgYWZmaWxpYXRlcy4gQWxsIHJpZ2h0cyByZXNlcnZlZC5cbiAqXG4gKiBMaWNlbnNlZCB1bmRlciB0aGUgQXBhY2hlIExpY2Vuc2UsIFZlcnNpb24gMi4wICh0aGUgXCJMaWNlbnNlXCIpO1xuICogeW91IG1heSBub3QgdXNlIHRoaXMgZmlsZSBleGNlcHQgaW4gY29tcGxpYW5jZSB3aXRoIHRoZSBMaWNlbnNlLlxuICogWW91IG1heSBvYnRhaW4gYSBjb3B5IG9mIHRoZSBMaWNlbnNlIGF0XG4gKlxuICogICAgIGh0dHA6Ly93d3cuYXBhY2hlLm9yZy9saWNlbnNlcy9MSUNFTlNFLTIuMFxuICpcbiAqIFVubGVzcyByZXF1aXJlZCBieSBhcHBsaWNhYmxlIGxhdyBvciBhZ3JlZWQgdG8gaW4gd3JpdGluZywgc29mdHdhcmVcbiAqIGRpc3RyaWJ1dGVkIHVuZGVyIHRoZSBMaWNlbnNlIGlzIGRpc3RyaWJ1dGVkIG9uIGFuIFwiQVMgSVNcIiBCQVNJUyxcbiAqIFdJVEhPVVQgV0FSUkFOVElFUyBPUiBDT05ESVRJT05TIE9GIEFOWSBLSU5ELCBlaXRoZXIgZXhwcmVzcyBvciBpbXBsaWVkLlxuICogU2VlIHRoZSBMaWNlbnNlIGZvciB0aGUgc3BlY2lmaWMgbGFuZ3VhZ2UgZ292ZXJuaW5nIHBlcm1pc3Npb25zIGFuZFxuICogbGltaXRhdGlvbnMgdW5kZXIgdGhlIExpY2Vuc2UuXG4gKi9cblxuZXhwb3J0IGludGVyZmFjZSBQcm9jZXNzVmFyaWFibGVNb2RlbCB7XG4gICAgc2VydmljZU5hbWU/OiBzdHJpbmc7XG4gICAgc2VydmljZUZ1bGxOYW1lPzogc3RyaW5nO1xuICAgIHNlcnZpY2VWZXJzaW9uPzogc3RyaW5nO1xuICAgIGFwcE5hbWU/OiBzdHJpbmc7XG4gICAgYXBwVmVyc2lvbj86IHN0cmluZztcbiAgICBzZXJ2aWNlVHlwZT86IHN0cmluZztcbiAgICBpZD86IG51bWJlcjtcbiAgICB0eXBlPzogc3RyaW5nO1xuICAgIG5hbWU/OiBzdHJpbmc7XG4gICAgY3JlYXRlVGltZT86IG51bWJlcjtcbiAgICBsYXN0VXBkYXRlZFRpbWU/OiBudW1iZXI7XG4gICAgZXhlY3V0aW9uSWQ/OiBzdHJpbmc7XG4gICAgdmFsdWU/OiBhbnk7XG4gICAgbWFya2VkQXNEZWxldGVkPzogYm9vbGVhbjtcbiAgICBwcm9jZXNzSW5zdGFuY2VJZD86IHN0cmluZztcbiAgICB0YXNrSWQ/OiBzdHJpbmc7XG4gICAgdGFza1ZhcmlhYmxlPzogYm9vbGVhbjtcbn1cbiJdfQ==

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

@@ -0,0 +1,34 @@
+/*!
+ * @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 { WidgetVisibilityModel } from '../../../models/widget-visibility.model';
+import { FormWidgetModel } from './form-widget.model';
+export class TabModel extends FormWidgetModel {
+    hasContent() {
+        return this.fields && this.fields.length > 0;
+    }
+    constructor(form, json) {
+        super(form, json);
+        this.isVisible = true;
+        this.fields = [];
+        if (json) {
+            this.title = json.title;
+            this.visibilityCondition = new WidgetVisibilityModel(json.visibilityCondition);
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/form/components/widgets/core/theme.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/form/components/widgets/core/upload-widget-content-link.model.mjs

@@ -0,0 +1,27 @@
+/*!
+ * @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 { ContentLinkModel } from './content-link.model';
+export class UploadWidgetContentLinkModelOptions {
+}
+export class UploadWidgetContentLinkModel extends ContentLinkModel {
+    constructor(obj, uploadWidgetId, options) {
+        super(obj);
+        this.options = options;
+        this.uploadWidgetId = uploadWidgetId;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/form/components/widgets/core/widget-schema.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/form/components/widgets/date/date.widget.mjs

@@ -0,0 +1,162 @@
+/*!
+ * @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 { NgIf } from '@angular/common';
+import { Component, DestroyRef, inject, ViewEncapsulation } from '@angular/core';
+import { FormControl, ReactiveFormsModule, Validators } from '@angular/forms';
+import { DateAdapter, MAT_DATE_FORMATS } from '@angular/material/core';
+import { MatDatepickerModule } from '@angular/material/datepicker';
+import { MatFormFieldModule } from '@angular/material/form-field';
+import { MatInputModule } from '@angular/material/input';
+import { TranslatePipe } from '@ngx-translate/core';
+import { ADF_DATE_FORMATS, AdfDateFnsAdapter, DateFnsUtils, DEFAULT_DATE_FORMAT } from '../../../../common';
+import { FormService } from '../../../services/form.service';
+import { ErrorWidgetComponent } from '../error/error.component';
+import { WidgetComponent } from '../widget.component';
+import { ErrorMessageModel } from '../core/error-message.model';
+import { parseISO } from 'date-fns';
+import { takeUntilDestroyed } from '@angular/core/rxjs-interop';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/material/form-field";
+import * as i2 from "@angular/material/input";
+import * as i3 from "@angular/material/datepicker";
+import * as i4 from "@angular/forms";
+export class DateWidgetComponent extends WidgetComponent {
+    constructor() {
+        super(...arguments);
+        this.dateInputControl = new FormControl(null);
+        this.formService = inject(FormService);
+        this.dateAdapter = inject(DateAdapter);
+        this.destroyRef = inject(DestroyRef);
+    }
+    ngOnInit() {
+        this.setFormControlValue();
+        this.updateFormControlState();
+        this.initDateAdapter();
+        this.initDateRange();
+        this.initStartAt();
+        this.subscribeToDateChanges();
+        this.validateField();
+    }
+    updateReactiveFormControl() {
+        this.updateFormControlState();
+        this.validateField();
+    }
+    setFormControlValue() {
+        this.dateInputControl.setValue(this.field.value, { emitEvent: false });
+    }
+    updateFormControlState() {
+        this.dateInputControl.setValidators(this.isRequired() && this.field?.isVisible ? [Validators.required] : []);
+        this.field?.readOnly || this.readOnly
+            ? this.dateInputControl.disable({ emitEvent: false })
+            : this.dateInputControl.enable({ emitEvent: false });
+        this.dateInputControl.updateValueAndValidity({ emitEvent: false });
+    }
+    subscribeToDateChanges() {
+        this.dateInputControl.valueChanges.pipe(takeUntilDestroyed(this.destroyRef)).subscribe((newDate) => {
+            this.field.value = newDate;
+            this.updateField();
+        });
+    }
+    updateField() {
+        this.validateField();
+        this.onFieldChanged(this.field);
+    }
+    validateField() {
+        if (this.dateInputControl.invalid) {
+            this.handleErrors(this.dateInputControl.errors);
+            this.field.markAsInvalid();
+        }
+        else {
+            this.resetErrors();
+            this.field.markAsValid();
+        }
+    }
+    handleErrors(errors) {
+        const errorAttributes = new Map();
+        switch (true) {
+            case !!errors.matDatepickerParse:
+                this.updateValidationSummary(this.field.dateDisplayFormat || this.field.defaultDateTimeFormat);
+                break;
+            case !!errors.required:
+                this.updateValidationSummary('FORM.FIELD.REQUIRED');
+                break;
+            case !!errors.matDatepickerMin: {
+                const minValue = DateFnsUtils.formatDate(errors.matDatepickerMin.min, this.field.dateDisplayFormat).toLocaleUpperCase();
+                errorAttributes.set('minValue', minValue);
+                this.updateValidationSummary('FORM.FIELD.VALIDATOR.NOT_LESS_THAN', errorAttributes);
+                break;
+            }
+            case !!errors.matDatepickerMax: {
+                const maxValue = DateFnsUtils.formatDate(errors.matDatepickerMax.max, this.field.dateDisplayFormat).toLocaleUpperCase();
+                errorAttributes.set('maxValue', maxValue);
+                this.updateValidationSummary('FORM.FIELD.VALIDATOR.NOT_GREATER_THAN', errorAttributes);
+                break;
+            }
+            default:
+                break;
+        }
+    }
+    updateValidationSummary(message, attributes) {
+        this.field.validationSummary = new ErrorMessageModel({ message, attributes });
+    }
+    resetErrors() {
+        this.updateValidationSummary('');
+    }
+    initDateAdapter() {
+        if (this.field?.dateDisplayFormat) {
+            const adapter = this.dateAdapter;
+            adapter.displayFormat = this.field.dateDisplayFormat;
+        }
+    }
+    initDateRange() {
+        if (this.field?.minValue) {
+            this.minDate = parseISO(this.field.minValue);
+        }
+        if (this.field?.maxValue) {
+            this.maxDate = parseISO(this.field.maxValue);
+        }
+    }
+    initStartAt() {
+        if (this.field?.value) {
+            this.startAt = this.dateAdapter.parse(this.field.value, DEFAULT_DATE_FORMAT);
+        }
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: DateWidgetComponent, deps: null, target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "18.2.13", type: DateWidgetComponent, isStandalone: true, selector: "date-widget", host: { listeners: { "click": "event($event)", "blur": "event($event)", "change": "event($event)", "focus": "event($event)", "focusin": "event($event)", "focusout": "event($event)", "input": "event($event)", "invalid": "event($event)", "select": "event($event)" } }, providers: [
+            { provide: MAT_DATE_FORMATS, useValue: ADF_DATE_FORMATS },
+            { provide: DateAdapter, useClass: AdfDateFnsAdapter }
+        ], usesInheritance: true, ngImport: i0, template: "<div class=\"{{ field.className }} date-widget-container\" id=\"data-widget\" [class.adf-invalid]=\"dateInputControl.invalid && dateInputControl.touched\">\n    <mat-form-field [floatLabel]=\"'always'\" class=\"adf-date-widget adf-form-field-input\" [floatLabel]=\"field.placeholder ? 'always' : null\">\n        <mat-label class=\"adf-label\"\n                   [id]=\"field.id + '-label'\"\n                   [attr.for]=\"field.id\">\n            {{ field.name | translate }} ({{ field.dateDisplayFormat }})\n        </mat-label>\n        <input matInput\n               [matDatepicker]=\"datePicker\"\n               [id]=\"field.id\"\n               [formControl]=\"dateInputControl\"\n               [placeholder]=\"field.placeholder\"\n               [min]=\"minDate\"\n               [max]=\"maxDate\"\n               [required]=\"field.required && field.isVisible\"\n               [readonly]=\"field.readOnly\"\n        />\n        <mat-datepicker-toggle matSuffix [for]=\"datePicker\" [disabled]=\"field.readOnly\" />\n        <mat-datepicker #datePicker\n                        [startAt]=\"startAt\"\n                        [disabled]=\"field.readOnly\" />\n    </mat-form-field>\n    <div class=\"adf-error-messages-container\">\n        <error-widget\n            *ngIf=\"dateInputControl.invalid && dateInputControl.touched\"\n            [error]=\"field.validationSummary\"\n        />\n    </div>\n</div>\n", styles: [".adf-widget-container{display:flex;align-items:flex-start;flex-direction:column}\n"], dependencies: [{ kind: "ngmodule", type: MatFormFieldModule }, { kind: "component", type: i1.MatFormField, selector: "mat-form-field", inputs: ["hideRequiredMarker", "color", "floatLabel", "appearance", "subscriptSizing", "hintLabel"], exportAs: ["matFormField"] }, { kind: "directive", type: i1.MatLabel, selector: "mat-label" }, { kind: "directive", type: i1.MatSuffix, selector: "[matSuffix], [matIconSuffix], [matTextSuffix]", inputs: ["matTextSuffix"] }, { kind: "pipe", type: TranslatePipe, name: "translate" }, { kind: "ngmodule", type: MatInputModule }, { kind: "directive", type: i2.MatInput, selector: "input[matInput], textarea[matInput], select[matNativeControl],      input[matNativeControl], textarea[matNativeControl]", inputs: ["disabled", "id", "placeholder", "name", "required", "type", "errorStateMatcher", "aria-describedby", "value", "readonly"], exportAs: ["matInput"] }, { kind: "ngmodule", type: MatDatepickerModule }, { kind: "component", type: i3.MatDatepicker, selector: "mat-datepicker", exportAs: ["matDatepicker"] }, { kind: "directive", type: i3.MatDatepickerInput, selector: "input[matDatepicker]", inputs: ["matDatepicker", "min", "max", "matDatepickerFilter"], exportAs: ["matDatepickerInput"] }, { kind: "component", type: i3.MatDatepickerToggle, selector: "mat-datepicker-toggle", inputs: ["for", "tabIndex", "aria-label", "disabled", "disableRipple"], exportAs: ["matDatepickerToggle"] }, { kind: "ngmodule", type: ReactiveFormsModule }, { kind: "directive", type: i4.DefaultValueAccessor, selector: "input:not([type=checkbox])[formControlName],textarea[formControlName],input:not([type=checkbox])[formControl],textarea[formControl],input:not([type=checkbox])[ngModel],textarea[ngModel],[ngDefaultControl]" }, { kind: "directive", type: i4.NgControlStatus, selector: "[formControlName],[ngModel],[formControl]" }, { kind: "directive", type: i4.RequiredValidator, selector: ":not([type=checkbox])[required][formControlName],:not([type=checkbox])[required][formControl],:not([type=checkbox])[required][ngModel]", inputs: ["required"] }, { kind: "directive", type: i4.FormControlDirective, selector: "[formControl]", inputs: ["formControl", "disabled", "ngModel"], outputs: ["ngModelChange"], exportAs: ["ngForm"] }, { kind: "component", type: ErrorWidgetComponent, selector: "error-widget", inputs: ["error", "required"] }, { kind: "directive", type: NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }], encapsulation: i0.ViewEncapsulation.None }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: DateWidgetComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'date-widget', standalone: true, providers: [
+                        { provide: MAT_DATE_FORMATS, useValue: ADF_DATE_FORMATS },
+                        { provide: DateAdapter, useClass: AdfDateFnsAdapter }
+                    ], host: {
+                        '(click)': 'event($event)',
+                        '(blur)': 'event($event)',
+                        '(change)': 'event($event)',
+                        '(focus)': 'event($event)',
+                        '(focusin)': 'event($event)',
+                        '(focusout)': 'event($event)',
+                        '(input)': 'event($event)',
+                        '(invalid)': 'event($event)',
+                        '(select)': 'event($event)'
+                    }, imports: [MatFormFieldModule, TranslatePipe, MatInputModule, MatDatepickerModule, ReactiveFormsModule, ErrorWidgetComponent, NgIf], encapsulation: ViewEncapsulation.None, template: "<div class=\"{{ field.className }} date-widget-container\" id=\"data-widget\" [class.adf-invalid]=\"dateInputControl.invalid && dateInputControl.touched\">\n    <mat-form-field [floatLabel]=\"'always'\" class=\"adf-date-widget adf-form-field-input\" [floatLabel]=\"field.placeholder ? 'always' : null\">\n        <mat-label class=\"adf-label\"\n                   [id]=\"field.id + '-label'\"\n                   [attr.for]=\"field.id\">\n            {{ field.name | translate }} ({{ field.dateDisplayFormat }})\n        </mat-label>\n        <input matInput\n               [matDatepicker]=\"datePicker\"\n               [id]=\"field.id\"\n               [formControl]=\"dateInputControl\"\n               [placeholder]=\"field.placeholder\"\n               [min]=\"minDate\"\n               [max]=\"maxDate\"\n               [required]=\"field.required && field.isVisible\"\n               [readonly]=\"field.readOnly\"\n        />\n        <mat-datepicker-toggle matSuffix [for]=\"datePicker\" [disabled]=\"field.readOnly\" />\n        <mat-datepicker #datePicker\n                        [startAt]=\"startAt\"\n                        [disabled]=\"field.readOnly\" />\n    </mat-form-field>\n    <div class=\"adf-error-messages-container\">\n        <error-widget\n            *ngIf=\"dateInputControl.invalid && dateInputControl.touched\"\n            [error]=\"field.validationSummary\"\n        />\n    </div>\n</div>\n", styles: [".adf-widget-container{display:flex;align-items:flex-start;flex-direction:column}\n"] }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"date.widget.js","sourceRoot":"","sources":["../../../../../../../../../lib/core/src/lib/form/components/widgets/date/date.widget.ts","../../../../../../../../../lib/core/src/lib/form/components/widgets/date/date.widget.html"],"names":[],"mappings":"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","sourcesContent":["/*!\n * @license\n * Copyright © 2005-2025 Hyland Software, Inc. and its affiliates. All rights reserved.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *     http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\n/* eslint-disable @angular-eslint/component-selector */\n\nimport { NgIf } from '@angular/common';\nimport { Component, DestroyRef, inject, OnInit, ViewEncapsulation } from '@angular/core';\nimport { FormControl, ReactiveFormsModule, ValidationErrors, Validators } from '@angular/forms';\nimport { DateAdapter, MAT_DATE_FORMATS } from '@angular/material/core';\nimport { MatDatepickerModule } from '@angular/material/datepicker';\nimport { MatFormFieldModule } from '@angular/material/form-field';\nimport { MatInputModule } from '@angular/material/input';\nimport { TranslatePipe } from '@ngx-translate/core';\nimport { ADF_DATE_FORMATS, AdfDateFnsAdapter, DateFnsUtils, DEFAULT_DATE_FORMAT } from '../../../../common';\nimport { FormService } from '../../../services/form.service';\nimport { ErrorWidgetComponent } from '../error/error.component';\nimport { WidgetComponent } from '../widget.component';\nimport { ErrorMessageModel } from '../core/error-message.model';\nimport { parseISO } from 'date-fns';\nimport { takeUntilDestroyed } from '@angular/core/rxjs-interop';\nimport { ReactiveFormWidget } from '../reactive-widget.interface';\n\n@Component({\n    selector: 'date-widget',\n    standalone: true,\n    providers: [\n        { provide: MAT_DATE_FORMATS, useValue: ADF_DATE_FORMATS },\n        { provide: DateAdapter, useClass: AdfDateFnsAdapter }\n    ],\n    templateUrl: './date.widget.html',\n    styleUrl: './date.widget.scss',\n    host: {\n        '(click)': 'event($event)',\n        '(blur)': 'event($event)',\n        '(change)': 'event($event)',\n        '(focus)': 'event($event)',\n        '(focusin)': 'event($event)',\n        '(focusout)': 'event($event)',\n        '(input)': 'event($event)',\n        '(invalid)': 'event($event)',\n        '(select)': 'event($event)'\n    },\n    imports: [MatFormFieldModule, TranslatePipe, MatInputModule, MatDatepickerModule, ReactiveFormsModule, ErrorWidgetComponent, NgIf],\n    encapsulation: ViewEncapsulation.None\n})\nexport class DateWidgetComponent extends WidgetComponent implements OnInit, ReactiveFormWidget {\n    minDate: Date;\n    maxDate: Date;\n    startAt: Date;\n\n    dateInputControl: FormControl<Date> = new FormControl<Date>(null);\n\n    public readonly formService = inject(FormService);\n\n    private readonly dateAdapter = inject(DateAdapter);\n    private readonly destroyRef = inject(DestroyRef);\n\n    ngOnInit(): void {\n        this.setFormControlValue();\n        this.updateFormControlState();\n        this.initDateAdapter();\n        this.initDateRange();\n        this.initStartAt();\n        this.subscribeToDateChanges();\n        this.validateField();\n    }\n\n    updateReactiveFormControl(): void {\n        this.updateFormControlState();\n        this.validateField();\n    }\n\n    private setFormControlValue(): void {\n        this.dateInputControl.setValue(this.field.value, { emitEvent: false });\n    }\n\n    private updateFormControlState(): void {\n        this.dateInputControl.setValidators(this.isRequired() && this.field?.isVisible ? [Validators.required] : []);\n        this.field?.readOnly || this.readOnly\n            ? this.dateInputControl.disable({ emitEvent: false })\n            : this.dateInputControl.enable({ emitEvent: false });\n\n        this.dateInputControl.updateValueAndValidity({ emitEvent: false });\n    }\n\n    private subscribeToDateChanges(): void {\n        this.dateInputControl.valueChanges.pipe(takeUntilDestroyed(this.destroyRef)).subscribe((newDate: Date) => {\n            this.field.value = newDate;\n            this.updateField();\n        });\n    }\n\n    private updateField(): void {\n        this.validateField();\n        this.onFieldChanged(this.field);\n    }\n\n    private validateField(): void {\n        if (this.dateInputControl.invalid) {\n            this.handleErrors(this.dateInputControl.errors);\n            this.field.markAsInvalid();\n        } else {\n            this.resetErrors();\n            this.field.markAsValid();\n        }\n    }\n\n    private handleErrors(errors: ValidationErrors): void {\n        const errorAttributes = new Map<string, string>();\n        switch (true) {\n            case !!errors.matDatepickerParse:\n                this.updateValidationSummary(this.field.dateDisplayFormat || this.field.defaultDateTimeFormat);\n                break;\n            case !!errors.required:\n                this.updateValidationSummary('FORM.FIELD.REQUIRED');\n                break;\n            case !!errors.matDatepickerMin: {\n                const minValue = DateFnsUtils.formatDate(errors.matDatepickerMin.min, this.field.dateDisplayFormat).toLocaleUpperCase();\n                errorAttributes.set('minValue', minValue);\n                this.updateValidationSummary('FORM.FIELD.VALIDATOR.NOT_LESS_THAN', errorAttributes);\n                break;\n            }\n            case !!errors.matDatepickerMax: {\n                const maxValue = DateFnsUtils.formatDate(errors.matDatepickerMax.max, this.field.dateDisplayFormat).toLocaleUpperCase();\n                errorAttributes.set('maxValue', maxValue);\n                this.updateValidationSummary('FORM.FIELD.VALIDATOR.NOT_GREATER_THAN', errorAttributes);\n                break;\n            }\n            default:\n                break;\n        }\n    }\n\n    private updateValidationSummary(message: string, attributes?: Map<string, string>): void {\n        this.field.validationSummary = new ErrorMessageModel({ message, attributes });\n    }\n\n    private resetErrors(): void {\n        this.updateValidationSummary('');\n    }\n\n    private initDateAdapter(): void {\n        if (this.field?.dateDisplayFormat) {\n            const adapter = this.dateAdapter as AdfDateFnsAdapter;\n            adapter.displayFormat = this.field.dateDisplayFormat;\n        }\n    }\n\n    private initDateRange(): void {\n        if (this.field?.minValue) {\n            this.minDate = parseISO(this.field.minValue);\n        }\n\n        if (this.field?.maxValue) {\n            this.maxDate = parseISO(this.field.maxValue);\n        }\n    }\n\n    private initStartAt(): void {\n        if (this.field?.value) {\n            this.startAt = this.dateAdapter.parse(this.field.value, DEFAULT_DATE_FORMAT);\n        }\n    }\n}\n","<div class=\"{{ field.className }} date-widget-container\" id=\"data-widget\" [class.adf-invalid]=\"dateInputControl.invalid && dateInputControl.touched\">\n    <mat-form-field [floatLabel]=\"'always'\" class=\"adf-date-widget adf-form-field-input\" [floatLabel]=\"field.placeholder ? 'always' : null\">\n        <mat-label class=\"adf-label\"\n                   [id]=\"field.id + '-label'\"\n                   [attr.for]=\"field.id\">\n            {{ field.name | translate }} ({{ field.dateDisplayFormat }})\n        </mat-label>\n        <input matInput\n               [matDatepicker]=\"datePicker\"\n               [id]=\"field.id\"\n               [formControl]=\"dateInputControl\"\n               [placeholder]=\"field.placeholder\"\n               [min]=\"minDate\"\n               [max]=\"maxDate\"\n               [required]=\"field.required && field.isVisible\"\n               [readonly]=\"field.readOnly\"\n        />\n        <mat-datepicker-toggle matSuffix [for]=\"datePicker\" [disabled]=\"field.readOnly\" />\n        <mat-datepicker #datePicker\n                        [startAt]=\"startAt\"\n                        [disabled]=\"field.readOnly\" />\n    </mat-form-field>\n    <div class=\"adf-error-messages-container\">\n        <error-widget\n            *ngIf=\"dateInputControl.invalid && dateInputControl.touched\"\n            [error]=\"field.validationSummary\"\n        />\n    </div>\n</div>\n"]}