@piserve-tech/form-submission 1.3.317 → 1.3.319

package/esm2022/services/aggregate.service.mjs

@@ -0,0 +1,139 @@
+import { Injectable } from '@angular/core';
+import { BehaviorSubject } from 'rxjs';
+import * as i0 from "@angular/core";
+export class AggregationFunctionService {
+    constructor() {
+        // New structure: { [rowId]: Map<fieldId, fieldData> }
+        this.aggregateFieldsMap = new Map();
+        this.numberFieldsMap = new Map();
+        this.aggregateFieldResultsSubject = new BehaviorSubject(null);
+        this.aggregateFieldResults$ = this.aggregateFieldResultsSubject.asObservable();
+    }
+    /**
+     * Store or update an aggregate field in the map
+     */
+    setAggregateField(rowId, fieldId, operation, formula) {
+        if (!this.aggregateFieldsMap.has(rowId)) {
+            this.aggregateFieldsMap.set(rowId, new Map());
+        }
+        this.aggregateFieldsMap.get(rowId).set(fieldId, { id: fieldId, operation, formula });
+    }
+    /**
+     * Store or update a number field in the map
+     */
+    setNumberField(rowId, fieldId, answer) {
+        if (!this.numberFieldsMap.has(rowId)) {
+            this.numberFieldsMap.set(rowId, new Map());
+        }
+        this.numberFieldsMap.get(rowId).set(fieldId, { id: fieldId, answer });
+        this.checkAndEvaluateFormulas(rowId);
+    }
+    emitAggregateResult(id, result, evaluated) {
+        this.aggregateFieldResultsSubject.next({ id, result, evaluated });
+    }
+    evaluateCustomFormula(rowId, formula) {
+        const rowNumberFields = this.numberFieldsMap.get(rowId);
+        if (!formula || !rowNumberFields)
+            return null;
+        const uuidRegex = /[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[1-5][0-9a-fA-F]{3}-[89abAB][0-9a-fA-F]{3}-[0-9a-fA-F]{12}/g;
+        /[0-9a-fA-F\-]{36}/g;
+        const uuidMatches = formula.match(uuidRegex) || [];
+        const allHaveAnswers = uuidMatches.every(uuid => {
+            const field = rowNumberFields.get(uuid);
+            return field !== undefined &&
+                field.answer !== undefined &&
+                field.answer !== null &&
+                String(field.answer).trim() !== '';
+        });
+        if (!allHaveAnswers)
+            return null;
+        const replacedFormula = formula.replace(uuidRegex, (match) => {
+            const field = rowNumberFields.get(match);
+            return field?.answer?.toString() || '0';
+        });
+        try {
+            return new Function(`return ${replacedFormula};`)();
+        }
+        catch (error) {
+            console.error('Error evaluating formula:', error);
+            return null;
+        }
+    }
+    evaluatePredefinedOperation(rowId, operation, formula) {
+        const rowNumberFields = this.numberFieldsMap.get(rowId);
+        if (!rowNumberFields)
+            return null;
+        const uuidList = formula.split(',').map(id => id.trim());
+        const values = [];
+        let hasAnyAnswer = false;
+        for (const uuid of uuidList) {
+            const field = rowNumberFields.get(uuid);
+            const val = field?.answer;
+            // If the field doesn't exist or value is invalid, push 0 as default
+            if (val !== undefined && val !== null && String(val).trim() !== '') {
+                hasAnyAnswer = true;
+                values.push(Number(val));
+            }
+            else {
+                values.push(0); // Still push 0 to keep array length, but flag stays false unless at least one answer exists
+            }
+        }
+        if (!hasAnyAnswer)
+            return null;
+        let result = 0;
+        switch (operation) {
+            case 'SUM':
+                result = values.reduce((acc, val) => acc + val, 0);
+                break;
+            case 'SUBTRACTION':
+                result = values.reduce((acc, val) => acc - val);
+                break;
+            case 'MULTIPLICATION':
+                result = values.reduce((acc, val) => acc * val, 1);
+                break;
+            default:
+                console.warn(`Unsupported operation: ${operation}`);
+                return null;
+        }
+        return result;
+    }
+    checkAndEvaluateFormulas(rowId) {
+        const aggregateFields = this.aggregateFieldsMap.get(rowId);
+        if (!aggregateFields)
+            return;
+        aggregateFields.forEach((aggregateField, id) => {
+            let result = null;
+            if (aggregateField.operation === 'CUSTOM') {
+                result = this.evaluateCustomFormula(rowId, aggregateField.formula);
+            }
+            else {
+                result = this.evaluatePredefinedOperation(rowId, aggregateField.operation, aggregateField.formula);
+            }
+            if (result !== null) {
+                aggregateField.result = result;
+                this.aggregateFieldsMap.get(rowId).set(id, aggregateField);
+                this.emitAggregateResult(`${rowId}:${id}`, result, true);
+            }
+            else {
+                this.emitAggregateResult(`${rowId}:${id}`, 0, false);
+            }
+        });
+    }
+    clearAll() {
+        this.aggregateFieldsMap.clear();
+        this.numberFieldsMap.clear();
+        this.aggregateFieldResultsSubject.next(null);
+    }
+    ngOnDestroy() {
+        this.clearAll();
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: AggregationFunctionService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: AggregationFunctionService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: AggregationFunctionService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: function () { return []; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"aggregate.service.js","sourceRoot":"","sources":["../../../../projects/form-submission/src/services/aggregate.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable, OnDestroy } from '@angular/core';\r\nimport { BehaviorSubject, Observable } from 'rxjs';\r\n\r\n\r\n@Injectable({\r\n  providedIn: 'root',\r\n})\r\nexport class AggregationFunctionService {\r\n\r\n  // New structure: { [rowId]: Map<fieldId, fieldData> }\r\nprivate aggregateFieldsMap = new Map<string, Map<string, { id: string; operation: string; formula: string; result?: number }>>();\r\nprivate numberFieldsMap = new Map<string, Map<string, { id: string; answer: number }>>();\r\n\r\n  private aggregateFieldResultsSubject = new BehaviorSubject<{ id: string; result: number,evaluated:boolean } | null>(null);\r\n  aggregateFieldResults$ = this.aggregateFieldResultsSubject.asObservable();\r\n\r\n  constructor() {}\r\n\r\n  /**\r\n   * Store or update an aggregate field in the map\r\n   */\r\n  setAggregateField(rowId: string, fieldId: string, operation: string, formula: string): void {\r\n    if (!this.aggregateFieldsMap.has(rowId)) {\r\n      this.aggregateFieldsMap.set(rowId, new Map());\r\n    }\r\n    this.aggregateFieldsMap.get(rowId)!.set(fieldId, { id: fieldId, operation, formula });\r\n  }\r\n\r\n  /**\r\n   * Store or update a number field in the map\r\n   */\r\n  setNumberField(rowId: string, fieldId: string, answer: number): void {\r\n    if (!this.numberFieldsMap.has(rowId)) {\r\n      this.numberFieldsMap.set(rowId, new Map());\r\n    }\r\n    this.numberFieldsMap.get(rowId)!.set(fieldId, { id: fieldId, answer });\r\n    this.checkAndEvaluateFormulas(rowId);\r\n  }\r\n\r\n  private emitAggregateResult(id: string, result: number,evaluated:boolean): void {\r\n    this.aggregateFieldResultsSubject.next({ id, result,evaluated });\r\n  }\r\n\r\n\r\n  evaluateCustomFormula(rowId: string, formula: string): number | null {\r\n    \r\n    const rowNumberFields = this.numberFieldsMap.get(rowId);\r\n    if (!formula || !rowNumberFields) return null;\r\n  \r\n    const uuidRegex = /[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[1-5][0-9a-fA-F]{3}-[89abAB][0-9a-fA-F]{3}-[0-9a-fA-F]{12}/g;/[0-9a-fA-F\\-]{36}/g;\r\n    const uuidMatches = formula.match(uuidRegex) || [];\r\n  \r\n    const allHaveAnswers = uuidMatches.every(uuid => {\r\n      const field = rowNumberFields.get(uuid);\r\n      return field !== undefined && \r\n             field.answer !== undefined && \r\n             field.answer !== null &&\r\n             String(field.answer).trim() !== '';\r\n    });\r\n  \r\n    if (!allHaveAnswers) return null;\r\n  \r\n    const replacedFormula = formula.replace(uuidRegex, (match) => {\r\n      const field = rowNumberFields.get(match);\r\n      return field?.answer?.toString() || '0';\r\n    });\r\n  \r\n    try {\r\n      return new Function(`return ${replacedFormula};`)();\r\n    } catch (error) {\r\n      console.error('Error evaluating formula:', error);\r\n      return null;\r\n    }\r\n  }\r\n  \r\n  evaluatePredefinedOperation(rowId: string, operation: string, formula: string): number | null {\r\n    const rowNumberFields = this.numberFieldsMap.get(rowId);\r\n    if (!rowNumberFields) return null;\r\n  \r\n    const uuidList = formula.split(',').map(id => id.trim());\r\n    const values: number[] = [];\r\n    let hasAnyAnswer = false;\r\n\r\n    for (const uuid of uuidList) {\r\n      const field = rowNumberFields.get(uuid);\r\n      const val = field?.answer;\r\n  \r\n      // If the field doesn't exist or value is invalid, push 0 as default\r\n      if (val !== undefined && val !== null && String(val).trim() !== '') {\r\n        hasAnyAnswer = true;\r\n        values.push(Number(val));\r\n      } else {\r\n        values.push(0); // Still push 0 to keep array length, but flag stays false unless at least one answer exists\r\n      }\r\n    }\r\n    if (!hasAnyAnswer) return null;\r\n    let result = 0;\r\n    switch (operation) {\r\n      case 'SUM':\r\n        result = values.reduce((acc, val) => acc + val, 0);\r\n        break;\r\n      case 'SUBTRACTION':\r\n        result = values.reduce((acc, val) => acc - val);\r\n        break;\r\n      case 'MULTIPLICATION':\r\n        result = values.reduce((acc, val) => acc * val, 1);\r\n        break;\r\n      default:\r\n        console.warn(`Unsupported operation: ${operation}`);\r\n        return null;\r\n    }\r\n  \r\n    return result;\r\n  }\r\n\r\n  checkAndEvaluateFormulas(rowId: string): void {\r\n    const aggregateFields = this.aggregateFieldsMap.get(rowId);\r\n    if (!aggregateFields) return;\r\n  \r\n    aggregateFields.forEach((aggregateField, id) => {\r\n      let result: number | null = null;\r\n  \r\n      if (aggregateField.operation === 'CUSTOM') {\r\n        result = this.evaluateCustomFormula(rowId, aggregateField.formula);\r\n      } else {\r\n        result = this.evaluatePredefinedOperation(rowId, aggregateField.operation, aggregateField.formula);\r\n      }\r\n  \r\n      if (result !== null) {\r\n        aggregateField.result = result;\r\n        this.aggregateFieldsMap.get(rowId)!.set(id, aggregateField);\r\n        this.emitAggregateResult(`${rowId}:${id}`, result,true);\r\n      } else {\r\n        this.emitAggregateResult(`${rowId}:${id}`, 0,false);\r\n      }\r\n    });\r\n  }\r\n\r\n  clearAll(): void {\r\n    this.aggregateFieldsMap.clear();\r\n    this.numberFieldsMap.clear();\r\n    this.aggregateFieldResultsSubject.next(null);\r\n  }\r\n  \r\n  ngOnDestroy(): void {\r\n    this.clearAll();\r\n  }\r\n}"]}

package/esm2022/services/countryService.mjs

@@ -0,0 +1,89 @@
+import { Injectable } from '@angular/core';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common/http";
+import * as i2 from "./data.service";
+export class CountryService {
+    constructor(http, dataService) {
+        this.http = http;
+        this.dataService = dataService;
+        this.apiUrl = '';
+        this.header = {};
+        this.dataService.apiUrl$.subscribe((data) => {
+            this.apiUrl = data;
+        });
+    }
+    loadCountryDetails(questionId, page, size, searchKey) {
+        return this.http.get(`${this.apiUrl}/api/public/json/country?page=${page}&size=${size}&searchKey=${encodeURIComponent(searchKey)}`);
+    }
+    processCountryDetails(data, displayFlag, displayCode, showCountryName) {
+        const countryDetails = [];
+        data.forEach((country) => {
+            const flag = displayFlag && country.flag ? country.flag : '';
+            const name = showCountryName ? country.name || '' : '';
+            const isdRoot = country.isd?.root || '';
+            const isdSuffixes = country.isd?.suffixes || [];
+            if (isdRoot && isdSuffixes.length > 0) {
+                isdSuffixes.forEach((suffix) => {
+                    const isdCode = `${isdRoot}${suffix}`;
+                    // Special case: Only flag should be displayed, but value must have ISD code
+                    if (displayFlag && !displayCode && !showCountryName) {
+                        countryDetails.push({
+                            value: isdCode,
+                            label: '',
+                            image: flag, //  Only flag should be displayed
+                        });
+                    }
+                    else {
+                        // Handle all other cases
+                        let label = '';
+                        if (showCountryName)
+                            label += name;
+                        if (displayCode)
+                            label += (label ? ' ' : '') + isdCode;
+                        if (!label)
+                            label = isdCode; // Ensure label is not empty
+                        countryDetails.push({
+                            value: isdCode,
+                            label: label.trim(),
+                            image: flag,
+                        });
+                    }
+                });
+            }
+            else {
+                const fallbackCode = isdRoot || country.code || ''; // Fallback if no suffixes
+                if (displayFlag && !displayCode && !showCountryName) {
+                    countryDetails.push({
+                        value: fallbackCode,
+                        label: '',
+                        image: flag,
+                    });
+                }
+                else {
+                    let label = '';
+                    if (showCountryName)
+                        label += name;
+                    if (displayCode)
+                        label += (label ? ' ' : '') + fallbackCode;
+                    if (!label)
+                        label = fallbackCode;
+                    countryDetails.push({
+                        value: fallbackCode,
+                        label: label.trim(),
+                        image: flag,
+                    });
+                }
+            }
+        });
+        return countryDetails;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: CountryService, deps: [{ token: i1.HttpClient }, { token: i2.DataService }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: CountryService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: CountryService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: function () { return [{ type: i1.HttpClient }, { type: i2.DataService }]; } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/services/data.service.mjs

@@ -0,0 +1,36 @@
+import { Injectable } from '@angular/core';
+import { BehaviorSubject } from 'rxjs';
+import * as i0 from "@angular/core";
+export class DataService {
+    constructor() {
+        this.dataSubject = new BehaviorSubject('');
+        this.apiUrl$ = this.dataSubject.asObservable();
+        this.headerSubject = new BehaviorSubject({});
+        this.header$ = this.headerSubject.asObservable();
+        this.subformSubject = new BehaviorSubject({});
+        this.subform$ = this.subformSubject.asObservable();
+        this.parentQuestionsSubject = new BehaviorSubject(null);
+        this.parentQuestions$ = this.parentQuestionsSubject.asObservable();
+    }
+    setApiUrl(data) {
+        this.dataSubject.next(data);
+    }
+    setHeader(data) {
+        this.headerSubject.next(data);
+    }
+    setParentQuestions(data) {
+        this.parentQuestionsSubject.next(data);
+    }
+    setSubformData(data) {
+        this.subformSubject.next(data);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: DataService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: DataService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: DataService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: function () { return []; } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/services/element-tracker.service.mjs

@@ -0,0 +1,27 @@
+// element-tracker.service.ts
+import { Injectable } from '@angular/core';
+import * as i0 from "@angular/core";
+export class ElementTrackerService {
+    constructor() {
+        this.elementIds = new Set();
+    }
+    registerElement(id) {
+        this.elementIds.add(id);
+    }
+    unregisterElement(id) {
+        this.elementIds.delete(id);
+    }
+    getAllElementIds() {
+        return Array.from(this.elementIds);
+    }
+    clear() {
+        this.elementIds.clear();
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: ElementTrackerService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: ElementTrackerService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: ElementTrackerService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZWxlbWVudC10cmFja2VyLnNlcnZpY2UuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9wcm9qZWN0cy9mb3JtLXN1Ym1pc3Npb24vc3JjL3NlcnZpY2VzL2VsZW1lbnQtdHJhY2tlci5zZXJ2aWNlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLDZCQUE2QjtBQUM3QixPQUFPLEVBQUUsVUFBVSxFQUFFLE1BQU0sZUFBZSxDQUFDOztBQUkzQyxNQUFNLE9BQU8scUJBQXFCO0lBRGxDO1FBRVUsZUFBVSxHQUFHLElBQUksR0FBRyxFQUFVLENBQUM7S0FpQnhDO0lBZkMsZUFBZSxDQUFDLEVBQVU7UUFDeEIsSUFBSSxDQUFDLFVBQVUsQ0FBQyxHQUFHLENBQUMsRUFBRSxDQUFDLENBQUM7SUFDMUIsQ0FBQztJQUVELGlCQUFpQixDQUFDLEVBQVU7UUFDMUIsSUFBSSxDQUFDLFVBQVUsQ0FBQyxNQUFNLENBQUMsRUFBRSxDQUFDLENBQUM7SUFDN0IsQ0FBQztJQUVELGdCQUFnQjtRQUNkLE9BQU8sS0FBSyxDQUFDLElBQUksQ0FBQyxJQUFJLENBQUMsVUFBVSxDQUFDLENBQUM7SUFDckMsQ0FBQztJQUVELEtBQUs7UUFDSCxJQUFJLENBQUMsVUFBVSxDQUFDLEtBQUssRUFBRSxDQUFDO0lBQzFCLENBQUM7K0dBakJVLHFCQUFxQjttSEFBckIscUJBQXFCLGNBRFIsTUFBTTs7NEZBQ25CLHFCQUFxQjtrQkFEakMsVUFBVTttQkFBQyxFQUFFLFVBQVUsRUFBRSxNQUFNLEVBQUUiLCJzb3VyY2VzQ29udGVudCI6WyIvLyBlbGVtZW50LXRyYWNrZXIuc2VydmljZS50c1xuaW1wb3J0IHsgSW5qZWN0YWJsZSB9IGZyb20gJ0Bhbmd1bGFyL2NvcmUnO1xuaW1wb3J0IHsgQmVoYXZpb3JTdWJqZWN0IH0gZnJvbSAncnhqcyc7XG5cbkBJbmplY3RhYmxlKHsgcHJvdmlkZWRJbjogJ3Jvb3QnIH0pXG5leHBvcnQgY2xhc3MgRWxlbWVudFRyYWNrZXJTZXJ2aWNlIHtcbiAgcHJpdmF0ZSBlbGVtZW50SWRzID0gbmV3IFNldDxzdHJpbmc+KCk7XG5cbiAgcmVnaXN0ZXJFbGVtZW50KGlkOiBzdHJpbmcpIHtcbiAgICB0aGlzLmVsZW1lbnRJZHMuYWRkKGlkKTtcbiAgfVxuXG4gIHVucmVnaXN0ZXJFbGVtZW50KGlkOiBzdHJpbmcpIHtcbiAgICB0aGlzLmVsZW1lbnRJZHMuZGVsZXRlKGlkKTtcbiAgfVxuXG4gIGdldEFsbEVsZW1lbnRJZHMoKTogc3RyaW5nW10ge1xuICAgIHJldHVybiBBcnJheS5mcm9tKHRoaXMuZWxlbWVudElkcyk7XG4gIH1cblxuICBjbGVhcigpIHtcbiAgICB0aGlzLmVsZW1lbnRJZHMuY2xlYXIoKTtcbiAgfVxufSJdfQ==

package/esm2022/services/form-validation.service.mjs

@@ -0,0 +1,128 @@
+import { Injectable } from '@angular/core';
+import * as i0 from "@angular/core";
+import * as i1 from "./validation.service";
+export class FormValidationService {
+    constructor(validationService) {
+        this.validationService = validationService;
+    }
+    /**
+     * Validate all required questions on a page.
+     * Assumes your `page` object has a `pageIndex: number` property.
+     */
+    validateRequiredQuestions(page) {
+        // clear any previous errors for this page
+        // this.validationService.clearAll();
+        const validateQuestions = (formElements, submissionContext = null) => {
+            for (let element of formElements) {
+                if (element.entityType === 'QUESTION') {
+                    const question = element.element;
+                    const required = question.required;
+                    const questionId = question.id;
+                    const elementType = question.formElement?.elementType;
+                    // pick up the answer (either in a subform or normal)
+                    let answer;
+                    if (submissionContext?.isInMultipleSubform) {
+                        const { submission } = submissionContext;
+                        answer = submission.answers.find((a) => a.questionId === questionId)?.answer;
+                    }
+                    else {
+                        answer = question.answer;
+                    }
+                    const isEmpty = answer === null ||
+                        answer === undefined ||
+                        (typeof answer === 'string' && answer.trim() === '') ||
+                        (typeof answer === 'object' && Object.keys(answer).length === 0);
+                    if (required && isEmpty) {
+                        const message = submissionContext?.isInMultipleSubform
+                            ? `Required question ${question.questionNumber} is not answered in a subform.`
+                            : `Required question ${question.questionNumber} is not answered.`;
+                        // register the invalid question
+                        this.validationService.setInvalid(questionId, message, page.pageIndex ?? 0);
+                        return { isValid: false, message };
+                    }
+                    // recurse into child logics
+                    if (question.childLogics) {
+                        for (let logic of question.childLogics) {
+                            if (!logic.showLogic)
+                                continue;
+                            for (let row of logic.rows) {
+                                const result = validateQuestions(row.grid, submissionContext);
+                                if (!result.isValid)
+                                    return result;
+                            }
+                        }
+                    }
+                }
+                else if (element.entityType === 'SUBFORM') {
+                    const subform = element.element;
+                    if (subform.property?.subFormStructure === 'multiple') {
+                        const submissions = subform.submissions || [];
+                        if (submissions.length > 0) {
+                            const hasRequired = subform.rows.some((r) => r.grid.some((f) => f.entityType === 'QUESTION' && f.element.required));
+                            if (hasRequired && submissions.length === 0) {
+                                const message = `Subform "${subform.title || 'Untitled'}" is missing required submissions.`;
+                                this.validationService.setInvalid(subform.id, message, page.pageIndex ?? 0);
+                                return { isValid: false, message };
+                            }
+                            // map questions and validate only if more than one submission
+                            const questionMap = new Map();
+                            subform.rows.forEach((r) => r.grid.forEach((f) => {
+                                if (f.entityType === 'QUESTION') {
+                                    questionMap.set(f.element.id, f.element);
+                                }
+                            }));
+                            for (let submission of submissions) {
+                                for (let row of subform.rows) {
+                                    const result = validateQuestions(row.grid, {
+                                        isInMultipleSubform: true,
+                                        submission,
+                                        questionMap,
+                                    });
+                                    if (!result.isValid)
+                                        return result;
+                                }
+                            }
+                        }
+                    }
+                    else {
+                        // single‐entry subform
+                        for (let row of subform.rows || []) {
+                            const result = validateQuestions(row.grid);
+                            if (!result.isValid)
+                                return result;
+                        }
+                    }
+                }
+                else if ((element.entityType === 'QUESTION_GROUP' ||
+                    element.entityType === 'MULTIFIELD') &&
+                    element.element.rows) {
+                    for (let row of element.element.rows) {
+                        const result = validateQuestions(row.grid, submissionContext);
+                        if (!result.isValid)
+                            return result;
+                    }
+                }
+            }
+            return { isValid: true, message: 'All required questions are answered.' };
+        };
+        // start validation
+        for (const row of page.rows) {
+            const result = validateQuestions(row.grid);
+            if (!result.isValid) {
+                // we already called setInvalid above
+                return result;
+            }
+        }
+        // if we get here, everything passed
+        return { isValid: true, message: 'All required questions are answered.' };
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: FormValidationService, deps: [{ token: i1.ValidationService }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: FormValidationService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: FormValidationService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: function () { return [{ type: i1.ValidationService }]; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"form-validation.service.js","sourceRoot":"","sources":["../../../../projects/form-submission/src/services/form-validation.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable } from '@angular/core';\r\nimport { ValidationService } from './validation.service';\r\n\r\n@Injectable({\r\n  providedIn: 'root',\r\n})\r\nexport class FormValidationService {\r\n  constructor(private validationService: ValidationService) {}\r\n\r\n  /**\r\n   * Validate all required questions on a page.\r\n   * Assumes your `page` object has a `pageIndex: number` property.\r\n   */\r\n  validateRequiredQuestions(page: any): { isValid: boolean; message: string } {\r\n    // clear any previous errors for this page\r\n    // this.validationService.clearAll();\r\n\r\n    const validateQuestions = (\r\n      formElements: any[],\r\n      submissionContext: any = null\r\n    ): { isValid: boolean; message: string } => {\r\n      for (let element of formElements) {\r\n        if (element.entityType === 'QUESTION') {\r\n          const question = element.element;\r\n          const required = question.required;\r\n          const questionId = question.id;\r\n          const elementType = question.formElement?.elementType;\r\n\r\n          // pick up the answer (either in a subform or normal)\r\n          let answer: any;\r\n          if (submissionContext?.isInMultipleSubform) {\r\n            const { submission } = submissionContext;\r\n            answer = submission.answers.find(\r\n              (a: any) => a.questionId === questionId\r\n            )?.answer;\r\n          } else {\r\n            answer = question.answer;\r\n          }\r\n\r\n          const isEmpty =\r\n            answer === null ||\r\n            answer === undefined ||\r\n            (typeof answer === 'string' && answer.trim() === '') ||\r\n            (typeof answer === 'object' && Object.keys(answer).length === 0);\r\n\r\n          if (required && isEmpty) {\r\n            const message = submissionContext?.isInMultipleSubform\r\n              ? `Required question ${question.questionNumber} is not answered in a subform.`\r\n              : `Required question ${question.questionNumber} is not answered.`;\r\n\r\n            // register the invalid question\r\n            this.validationService.setInvalid(\r\n              questionId,\r\n              message,\r\n              page.pageIndex ?? 0\r\n            );\r\n\r\n            return { isValid: false, message };\r\n          }\r\n\r\n          // recurse into child logics\r\n          if (question.childLogics) {\r\n            for (let logic of question.childLogics) {\r\n              if (!logic.showLogic) continue;\r\n              for (let row of logic.rows) {\r\n                const result = validateQuestions(row.grid, submissionContext);\r\n                if (!result.isValid) return result;\r\n              }\r\n            }\r\n          }\r\n        } else if (element.entityType === 'SUBFORM') {\r\n          const subform = element.element;\r\n\r\n          if (subform.property?.subFormStructure === 'multiple') {\r\n            const submissions = subform.submissions || [];\r\n\r\n            if (submissions.length > 0) {\r\n              const hasRequired = subform.rows.some((r: any) =>\r\n                r.grid.some(\r\n                  (f: any) => f.entityType === 'QUESTION' && f.element.required\r\n                )\r\n              );\r\n\r\n              if (hasRequired && submissions.length === 0) {\r\n                const message = `Subform \"${\r\n                  subform.title || 'Untitled'\r\n                }\" is missing required submissions.`;\r\n                this.validationService.setInvalid(\r\n                  subform.id,\r\n                  message,\r\n                  page.pageIndex ?? 0\r\n                );\r\n                return { isValid: false, message };\r\n              }\r\n\r\n              // map questions and validate only if more than one submission\r\n              const questionMap = new Map<string, any>();\r\n              subform.rows.forEach((r: any) =>\r\n                r.grid.forEach((f: any) => {\r\n                  if (f.entityType === 'QUESTION') {\r\n                    questionMap.set(f.element.id, f.element);\r\n                  }\r\n                })\r\n              );\r\n\r\n              for (let submission of submissions) {\r\n                for (let row of subform.rows) {\r\n                  const result = validateQuestions(row.grid, {\r\n                    isInMultipleSubform: true,\r\n                    submission,\r\n                    questionMap,\r\n                  });\r\n                  if (!result.isValid) return result;\r\n                }\r\n              }\r\n            }\r\n          } else {\r\n            // single‐entry subform\r\n            for (let row of subform.rows || []) {\r\n              const result = validateQuestions(row.grid);\r\n              if (!result.isValid) return result;\r\n            }\r\n          }\r\n        } else if (\r\n          (element.entityType === 'QUESTION_GROUP' ||\r\n            element.entityType === 'MULTIFIELD') &&\r\n          element.element.rows\r\n        ) {\r\n          for (let row of element.element.rows) {\r\n            const result = validateQuestions(row.grid, submissionContext);\r\n            if (!result.isValid) return result;\r\n          }\r\n        }\r\n      }\r\n\r\n      return { isValid: true, message: 'All required questions are answered.' };\r\n    };\r\n\r\n    // start validation\r\n    for (const row of page.rows) {\r\n      const result = validateQuestions(row.grid);\r\n      if (!result.isValid) {\r\n        // we already called setInvalid above\r\n        return result;\r\n      }\r\n    }\r\n\r\n    // if we get here, everything passed\r\n    return { isValid: true, message: 'All required questions are answered.' };\r\n  }\r\n}\r\n"]}