@piserve-tech/form-submission 1.3.317 → 1.3.319

package/esm2022/services/validation.service.mjs

@@ -0,0 +1,35 @@
+import { Injectable } from '@angular/core';
+import * as i0 from "@angular/core";
+export class ValidationService {
+    constructor() {
+        this.invalidQuestions = {};
+    }
+    setInvalid(questionId, message, pageIndex) {
+        this.invalidQuestions[questionId] = { message, pageIndex };
+    }
+    clearInvalid(questionId) {
+        delete this.invalidQuestions[questionId];
+    }
+    getFirstInvalid() {
+        const keys = Object.keys(this.invalidQuestions);
+        return keys.length > 0 ? {
+            id: keys[0],
+            pageIndex: this.invalidQuestions[keys[0]].pageIndex
+        } : null;
+    }
+    getErrorMessage(questionId) {
+        return this.invalidQuestions[questionId]?.message || null;
+    }
+    clearAll() {
+        this.invalidQuestions = {};
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: ValidationService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: ValidationService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: ValidationService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/services/whenClause.service.mjs

@@ -0,0 +1,423 @@
+import { Injectable } from '@angular/core';
+import { Subject } from 'rxjs/internal/Subject';
+import * as i0 from "@angular/core";
+export class WhenClauseService {
+    constructor() {
+        this.activeWhenClauseGrids = [];
+        this.questionAnswerMap = {};
+        this.questionChange$ = new Subject();
+        this.isInitialLoad = true;
+    }
+    markLoadCompleted() {
+        this.isInitialLoad = false;
+    }
+    onQuestionChange() {
+        return this.questionChange$.asObservable();
+    }
+    /**
+     * Check if a grid has an active when clause
+     */
+    isActiveWhenClause(grid) {
+        const when = grid?.whenClause;
+        return !!(when &&
+            when.activate &&
+            Array.isArray(when.whenClauseCondition) &&
+            when.whenClauseCondition.length > 0);
+    }
+    /**
+     * Add a grid to tracking list if it has an active when clause
+     */
+    addGrid(grid) {
+        if (!grid)
+            return;
+        if (this.isActiveWhenClause(grid)) {
+            const exists = this.activeWhenClauseGrids.some((g) => g.element?.id === grid.element?.id);
+            if (!exists) {
+                this.activeWhenClauseGrids.push(grid);
+            }
+        }
+    }
+    setQuestionAnswer(questionId, answer, initial = false) {
+        if (!questionId)
+            return;
+        this.questionAnswerMap[questionId] = answer;
+        this.evaluateAllWhenClauses(initial);
+        this.questionChange$.next({ questionId });
+    }
+    getAnswer(questionId) {
+        return this.questionAnswerMap[questionId];
+    }
+    evaluateAllWhenClauses(initial) {
+        const visibleGrids = [];
+        for (const grid of this.activeWhenClauseGrids) {
+            const when = grid.whenClause;
+            const conditions = when.whenClauseCondition;
+            if (!conditions || !conditions.length)
+                continue;
+            let overallResult = true;
+            for (let i = 0; i < conditions.length; i++) {
+                const clause = conditions[i];
+                const logic = (clause.logic || (i === 0 ? 'AND' : 'AND')).toUpperCase(); // Default to AND for first
+                const answer = this.getAnswer(clause.questionid);
+                const result = this.evaluateCondition(answer, clause.condition, clause.value);
+                // Combine results based on logic (AND / OR)
+                if (i === 0) {
+                    overallResult = result; // initialize with first condition
+                }
+                else {
+                    if (logic === 'AND') {
+                        overallResult = overallResult && result;
+                    }
+                    else if (logic === 'OR') {
+                        overallResult = overallResult || result;
+                    }
+                }
+            }
+            // safe read actions (could be undefined)
+            const actions = Array.isArray(when?.whenClauseActions)
+                ? when.whenClauseActions.map(String)
+                : [];
+            // choose the decisive action (use last if multiple)
+            const action = actions.length > 0 ? actions[actions.length - 1] : undefined;
+            if (overallResult) {
+                // Condition(s) satisfied -> perform the action
+                switch (action) {
+                    case 'SHOW':
+                        grid.show = true;
+                        break;
+                    case 'HIDE':
+                        grid.show = false;
+                        break;
+                    case 'MARK_AS_REQUIRED':
+                        if (grid.element)
+                            grid.element.required = true;
+                        break;
+                    case 'MARK_AS_OPTIONAL':
+                        if (grid.element)
+                            grid.element.required = false;
+                        break;
+                    default:
+                        // no show/hide action — keep current behavior (you can choose default here)
+                        // For safety, if no explicit action, we'll leave grid.show unchanged.
+                        break;
+                }
+                // if visible, collect
+                if (grid.show)
+                    visibleGrids.push(grid);
+            }
+            else {
+                // Condition(s) not satisfied -> revert the action's effect
+                switch (action) {
+                    case 'SHOW':
+                        // condition no longer true => hide (revert)
+                        grid.show = false;
+                        break;
+                    case 'HIDE':
+                        // condition no longer true => show (revert)
+                        grid.show = true;
+                        break;
+                    case 'MARK_AS_REQUIRED':
+                        if (grid.element)
+                            grid.element.required = false;
+                        break;
+                    case 'MARK_AS_OPTIONAL':
+                        if (grid.element)
+                            grid.element.required = true;
+                        break;
+                    default:
+                        // nothing to revert
+                        break;
+                }
+                // if we hid it because overallResult false and it's not initial, clear answer
+                if (!overallResult && !initial && !grid.show) {
+                    grid.element.answer = null;
+                }
+            }
+            if (overallResult)
+                visibleGrids.push(grid);
+        }
+    }
+    evaluateCondition(answer, operator, value) {
+        // treat null/undefined/empty-string/empty-array as "no answer"
+        if (answer === null || answer === undefined)
+            return false;
+        // if (typeof answer === 'string' && answer === '') return false;
+        if (Array.isArray(answer) && answer.length === 0)
+            return false;
+        // helpers to normalize values to arrays of lower-case strings (for string ops)
+        const toStr = (v) => v === null || v === undefined ? '' : String(v).toLowerCase();
+        const ensureArray = (v) => {
+            if (Array.isArray(v))
+                return v.map((x) => toStr(x));
+            // if comma-separated string => split, else single element array
+            if (typeof v === 'string' && v.indexOf(',') !== -1) {
+                return v
+                    .split(',')
+                    .map((x) => x.trim())
+                    .map((x) => toStr(x));
+            }
+            return [toStr(v)];
+        };
+        const ansArr = ensureArray(answer);
+        const valArr = ensureArray(value);
+        // numeric comparisons: only when both sides are scalars (non-array) and numeric
+        const isNumericScalar = (x) => !Array.isArray(x) && x !== null && x !== undefined && !Number.isNaN(Number(x));
+        switch (operator) {
+            case '<':
+                if (isNumericScalar(answer) && isNumericScalar(value))
+                    return Number(answer) < Number(value);
+                return false;
+            case '>':
+                if (isNumericScalar(answer) && isNumericScalar(value))
+                    return Number(answer) > Number(value);
+                return false;
+            case '<=':
+                if (isNumericScalar(answer) && isNumericScalar(value))
+                    return Number(answer) <= Number(value);
+                return false;
+            case '>=':
+                if (isNumericScalar(answer) && isNumericScalar(value))
+                    return Number(answer) >= Number(value);
+                return false;
+            // equality: true if any answer element equals any value element
+            case '=':
+                return ansArr.some((a) => valArr.some((v) => a === v));
+            case '!=':
+                return !ansArr.some((a) => valArr.some((v) => a === v));
+            // LIKE / NOT LIKE: check substring match anywhere in any answer element
+            case 'LIKE':
+                return ansArr.some((a) => valArr.some((v) => a.includes(v)));
+            case 'NOT LIKE':
+                return !ansArr.some((a) => valArr.some((v) => a.includes(v)));
+            case 'BEGIN WITH':
+                return ansArr.some((a) => valArr.some((v) => a.startsWith(v)));
+            case 'END WITH':
+                return ansArr.some((a) => valArr.some((v) => a.endsWith(v)));
+            // IN / NOT IN: true if any answer element exists in value list
+            case 'IN':
+                return ansArr.some((a) => valArr.includes(a));
+            case 'NOT IN':
+                return !ansArr.some((a) => valArr.includes(a));
+            default:
+                return false;
+        }
+    }
+    addGridsFromSubform(subform) {
+        if (!subform || !Array.isArray(subform.rows))
+            return;
+        for (const row of subform.rows) {
+            if (!row.grid || !Array.isArray(row.grid))
+                continue;
+            for (const grid of row.grid) {
+                // 1️⃣ Add this grid itself if it has an active whenClause
+                this.addGrid(grid);
+                // 2️⃣ Then, recursively process nested childLogics inside its element
+                if (grid.element?.childLogics?.length) {
+                    this.processChildLogics(grid.element.childLogics);
+                }
+            }
+        }
+    }
+    /**
+     * Recursively process childLogics structure
+     */
+    processChildLogics(childLogics) {
+        if (!Array.isArray(childLogics))
+            return;
+        for (const logic of childLogics) {
+            // 1️⃣ Each logic may have its own rows (similar to subform rows)
+            if (Array.isArray(logic.rows)) {
+                for (const row of logic.rows) {
+                    if (Array.isArray(row.grid)) {
+                        for (const grid of row.grid) {
+                            // Check whenClause for this nested grid
+                            this.addGrid(grid);
+                            // 2️⃣ Recurse again if this nested question also has its own childLogics
+                            if (grid.element?.childLogics?.length) {
+                                this.processChildLogics(grid.element.childLogics);
+                            }
+                        }
+                    }
+                }
+            }
+            // 3️⃣ A logic itself might directly contain nested logics
+            if (Array.isArray(logic.childLogics)) {
+                this.processChildLogics(logic.childLogics);
+            }
+        }
+    }
+    /**
+     * Return ALL elements with an active whenClause inside a subform,
+     * including nested childLogics (recursive)
+     */
+    getWhenClauseElements(subform) {
+        const result = [];
+        if (!subform || !Array.isArray(subform.rows)) {
+            return result;
+        }
+        for (const row of subform.rows) {
+            if (!Array.isArray(row.grid))
+                continue;
+            for (const grid of row.grid) {
+                // 1️⃣ Add this grid if it has an active whenClause
+                if (this.isActiveWhenClause(grid)) {
+                    result.push(grid);
+                }
+                // 2️⃣ Process nested childLogics inside this element
+                if (Array.isArray(grid.element?.childLogics)) {
+                    result.push(...this.getElementsFromChildLogics(grid.element.childLogics));
+                }
+            }
+        }
+        return result;
+    }
+    /**
+     * Recursively gather grids with active whenClause inside childLogics
+     */
+    getElementsFromChildLogics(childLogics) {
+        const found = [];
+        if (!Array.isArray(childLogics))
+            return found;
+        for (const logic of childLogics) {
+            // Each logic can have rows
+            if (Array.isArray(logic.rows)) {
+                for (const row of logic.rows) {
+                    if (!Array.isArray(row.grid))
+                        continue;
+                    for (const grid of row.grid) {
+                        if (this.isActiveWhenClause(grid)) {
+                            found.push(grid);
+                        }
+                        // Recurse deeper if this grid has nested childLogics
+                        if (Array.isArray(grid.element?.childLogics)) {
+                            found.push(...this.getElementsFromChildLogics(grid.element.childLogics));
+                        }
+                    }
+                }
+            }
+            // Logic itself may have nested childLogics
+            if (Array.isArray(logic.childLogics)) {
+                found.push(...this.getElementsFromChildLogics(logic.childLogics));
+            }
+        }
+        return found;
+    }
+    checkElementVisibility(id, submission) {
+        if (!id || !submission || !Array.isArray(submission.answers)) {
+            return true; // default visible if invalid input
+        }
+        const matchedAnswer = submission.answers.find((ans) => ans.questionId === id);
+        // Return the 'show' flag if found, else default to true
+        return matchedAnswer ? matchedAnswer.show ?? true : true;
+    }
+    evaluateSubformWhenClauses(changedAnswer, submission, changedQuestionId, elementsWithWhenClause) {
+        if (!elementsWithWhenClause.length)
+            return;
+        for (const grid of elementsWithWhenClause) {
+            const elementId = grid.element.id;
+            const when = grid.whenClause;
+            const conditions = when.whenClauseCondition;
+            if (!conditions?.length)
+                continue;
+            let overallResult = true;
+            for (let i = 0; i < conditions.length; i++) {
+                const clause = conditions[i];
+                const logic = (clause.logic || (i === 0 ? 'AND' : 'AND')).toUpperCase();
+                // Determine which answer to use for this condition
+                let answerToCheck;
+                if (clause.questionid === changedQuestionId) {
+                    // Use updated answer for the changed question
+                    answerToCheck = changedAnswer;
+                }
+                else {
+                    // Fetch existing value from submission for other questions
+                    const existing = submission.answers.find((a) => a.questionId === clause.questionid);
+                    answerToCheck = existing?.answer;
+                }
+                const result = this.evaluateCondition(answerToCheck, clause.condition, clause.value);
+                // Apply AND/OR logic
+                if (i === 0) {
+                    overallResult = result;
+                }
+                else {
+                    overallResult =
+                        logic === 'AND' ? overallResult && result : overallResult || result;
+                }
+            }
+            // Update show flag for the element controlled by this whenClause
+            const matchedAnswer = submission.answers.find((ans) => ans.questionId === elementId);
+            const actions = Array.isArray(when?.whenClauseActions)
+                ? when.whenClauseActions.map(String)
+                : [];
+            // choose the decisive action (use last if multiple)
+            const action = actions.length > 0 ? actions[actions.length - 1] : undefined;
+            if (matchedAnswer) {
+                if (overallResult) {
+                    // Condition(s) satisfied -> perform the action
+                    switch (action) {
+                        case 'SHOW':
+                            matchedAnswer.show = true;
+                            break;
+                        case 'HIDE':
+                            matchedAnswer.show = false;
+                            break;
+                        case 'MARK_AS_REQUIRED':
+                            matchedAnswer.required = true;
+                            break;
+                        case 'MARK_AS_OPTIONAL':
+                            matchedAnswer.required = false;
+                            break;
+                        default:
+                            // no show/hide action — keep current behavior (you can choose default here)
+                            // For safety, if no explicit action, we'll leave grid.show unchanged.
+                            break;
+                    }
+                }
+                else {
+                    // Condition(s) not satisfied -> revert the action's effect
+                    switch (action) {
+                        case 'SHOW':
+                            // condition no longer true => hide (revert)
+                            matchedAnswer.show = false;
+                            break;
+                        case 'HIDE':
+                            // condition no longer true => show (revert)
+                            matchedAnswer.show = true;
+                            break;
+                        case 'MARK_AS_REQUIRED':
+                            matchedAnswer.required = false;
+                            break;
+                        case 'MARK_AS_OPTIONAL':
+                            matchedAnswer.required = true;
+                            break;
+                        default:
+                            // nothing to revert
+                            break;
+                    }
+                }
+            }
+            // if (matchedAnswer) {
+            //   matchedAnswer.show = overallResult;
+            // }
+        }
+    }
+    resetService() {
+        // Clear tracked grids
+        this.activeWhenClauseGrids = [];
+        // Clear stored question → answer map
+        this.questionAnswerMap = {};
+        // Reset visibility logic to initial state
+    }
+    getActiveWhenClauseGrids() {
+        return this.activeWhenClauseGrids;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: WhenClauseService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: WhenClauseService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: WhenClauseService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: function () { return []; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"whenClause.service.js","sourceRoot":"","sources":["../../../../projects/form-submission/src/services/whenClause.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable } from '@angular/core';\r\nimport { Submission } from '../models/submission.model';\r\nimport { Subject } from 'rxjs/internal/Subject';\r\n\r\n@Injectable({\r\n  providedIn: 'root',\r\n})\r\nexport class WhenClauseService {\r\n  private activeWhenClauseGrids: any[] = [];\r\n  private questionAnswerMap: { [questionId: string]: any } = {};\r\nprivate questionChange$ = new Subject<{ questionId: string }>();\r\n\r\n\r\n\r\n  isInitialLoad: boolean = true;\r\n  constructor() {}\r\n\r\n  markLoadCompleted() {\r\n    this.isInitialLoad = false;\r\n  }\r\n\r\n  onQuestionChange() {\r\n  return this.questionChange$.asObservable();\r\n}\r\n\r\n\r\n  /**\r\n   * Check if a grid has an active when clause\r\n   */\r\n  isActiveWhenClause(grid: any): boolean {\r\n    const when = grid?.whenClause;\r\n    return !!(\r\n      when &&\r\n      when.activate &&\r\n      Array.isArray(when.whenClauseCondition) &&\r\n      when.whenClauseCondition.length > 0\r\n    );\r\n  }\r\n\r\n  /**\r\n   * Add a grid to tracking list if it has an active when clause\r\n   */\r\n  addGrid(grid: any): void {\r\n    if (!grid) return;\r\n\r\n    if (this.isActiveWhenClause(grid)) {\r\n      const exists = this.activeWhenClauseGrids.some(\r\n        (g) => g.element?.id === grid.element?.id\r\n      );\r\n\r\n      if (!exists) {\r\n        this.activeWhenClauseGrids.push(grid);\r\n      }\r\n    }\r\n  }\r\n\r\n  setQuestionAnswer(questionId: string, answer: any,initial:boolean = false): void {\r\n    if (!questionId) return;\r\n    this.questionAnswerMap[questionId] = answer;\r\n    this.evaluateAllWhenClauses(initial);\r\n      this.questionChange$.next({ questionId });\r\n  }\r\n\r\n  getAnswer(questionId: string): any {\r\n    return this.questionAnswerMap[questionId];\r\n  }\r\n\r\n  private evaluateAllWhenClauses(initial:boolean): void {\r\n    const visibleGrids: any[] = [];\r\n\r\n    for (const grid of this.activeWhenClauseGrids) {\r\n      const when = grid.whenClause;\r\n      const conditions = when.whenClauseCondition;\r\n\r\n      if (!conditions || !conditions.length) continue;\r\n\r\n      let overallResult = true;\r\n\r\n      for (let i = 0; i < conditions.length; i++) {\r\n        const clause = conditions[i];\r\n        const logic = (clause.logic || (i === 0 ? 'AND' : 'AND')).toUpperCase(); // Default to AND for first\r\n        const answer = this.getAnswer(clause.questionid);\r\n        const result = this.evaluateCondition(\r\n          answer,\r\n          clause.condition,\r\n          clause.value\r\n        );\r\n\r\n        // Combine results based on logic (AND / OR)\r\n        if (i === 0) {\r\n          overallResult = result; // initialize with first condition\r\n        } else {\r\n          if (logic === 'AND') {\r\n            overallResult = overallResult && result;\r\n          } else if (logic === 'OR') {\r\n            overallResult = overallResult || result;\r\n          }\r\n        }\r\n      }\r\n      // safe read actions (could be undefined)\r\n    const actions: string[] = Array.isArray(when?.whenClauseActions)\r\n    ? when.whenClauseActions.map(String)\r\n    : [];\r\n\r\n  // choose the decisive action (use last if multiple)\r\n  const action = actions.length > 0 ? actions[actions.length - 1] : undefined;\r\n\r\n  if (overallResult) {\r\n    // Condition(s) satisfied -> perform the action\r\n    switch (action) {\r\n      case 'SHOW':\r\n        grid.show = true;\r\n        break;\r\n      case 'HIDE':\r\n        grid.show = false;\r\n        break;\r\n      case 'MARK_AS_REQUIRED':\r\n        if (grid.element) grid.element.required = true;\r\n        break;\r\n      case 'MARK_AS_OPTIONAL':\r\n        if (grid.element) grid.element.required = false;\r\n        break;\r\n      default:\r\n        // no show/hide action — keep current behavior (you can choose default here)\r\n        // For safety, if no explicit action, we'll leave grid.show unchanged.\r\n        break;\r\n    }\r\n\r\n    // if visible, collect\r\n    if (grid.show) visibleGrids.push(grid);\r\n  } else {\r\n    // Condition(s) not satisfied -> revert the action's effect\r\n    switch (action) {\r\n      case 'SHOW':\r\n        // condition no longer true => hide (revert)\r\n        grid.show = false;\r\n        break;\r\n      case 'HIDE':\r\n        // condition no longer true => show (revert)\r\n        grid.show = true;\r\n        break;\r\n      case 'MARK_AS_REQUIRED':\r\n        if (grid.element) grid.element.required = false;\r\n        break;\r\n      case 'MARK_AS_OPTIONAL':\r\n        if (grid.element) grid.element.required = true;\r\n        break;\r\n      default:\r\n        // nothing to revert\r\n        break;\r\n    }\r\n    // if we hid it because overallResult false and it's not initial, clear answer\r\n    if (!overallResult && !initial && !grid.show) {\r\n      grid.element.answer = null;\r\n    }\r\n  }\r\n      if (overallResult) visibleGrids.push(grid);\r\n    }\r\n  }\r\n\r\n  evaluateCondition(answer: any, operator: string, value: any): boolean {\r\n\r\n    // treat null/undefined/empty-string/empty-array as \"no answer\"\r\n    if (answer === null || answer === undefined) return false;\r\n    // if (typeof answer === 'string' && answer === '') return false;\r\n    if (Array.isArray(answer) && answer.length === 0) return false;\r\n\r\n    // helpers to normalize values to arrays of lower-case strings (for string ops)\r\n    const toStr = (v: any) =>\r\n      v === null || v === undefined ? '' : String(v).toLowerCase();\r\n\r\n    const ensureArray = (v: any): string[] => {\r\n      if (Array.isArray(v)) return v.map((x) => toStr(x));\r\n      // if comma-separated string => split, else single element array\r\n      if (typeof v === 'string' && v.indexOf(',') !== -1) {\r\n        return v\r\n          .split(',')\r\n          .map((x) => x.trim())\r\n          .map((x) => toStr(x));\r\n      }\r\n      return [toStr(v)];\r\n    };\r\n\r\n    const ansArr = ensureArray(answer);\r\n    const valArr = ensureArray(value);\r\n\r\n    // numeric comparisons: only when both sides are scalars (non-array) and numeric\r\n    const isNumericScalar = (x: any) =>\r\n      !Array.isArray(x) && x !== null && x !== undefined && !Number.isNaN(Number(x));\r\n\r\n    switch (operator) {\r\n      case '<':\r\n        if (isNumericScalar(answer) && isNumericScalar(value))\r\n          return Number(answer) < Number(value);\r\n        return false;\r\n      case '>':\r\n        if (isNumericScalar(answer) && isNumericScalar(value))\r\n          return Number(answer) > Number(value);\r\n        return false;\r\n      case '<=':\r\n        if (isNumericScalar(answer) && isNumericScalar(value))\r\n          return Number(answer) <= Number(value);\r\n        return false;\r\n      case '>=':\r\n        if (isNumericScalar(answer) && isNumericScalar(value))\r\n          return Number(answer) >= Number(value);\r\n        return false;\r\n\r\n      // equality: true if any answer element equals any value element\r\n      case '=':\r\n        return ansArr.some((a) => valArr.some((v) => a === v));\r\n\r\n      case '!=':\r\n        return !ansArr.some((a) => valArr.some((v) => a === v));\r\n\r\n      // LIKE / NOT LIKE: check substring match anywhere in any answer element\r\n      case 'LIKE':\r\n        return ansArr.some((a) => valArr.some((v) => a.includes(v)));\r\n      case 'NOT LIKE':\r\n        return !ansArr.some((a) => valArr.some((v) => a.includes(v)));\r\n\r\n      case 'BEGIN WITH':\r\n        return ansArr.some((a) => valArr.some((v) => a.startsWith(v)));\r\n      case 'END WITH':\r\n        return ansArr.some((a) => valArr.some((v) => a.endsWith(v)));\r\n\r\n      // IN / NOT IN: true if any answer element exists in value list\r\n      case 'IN':\r\n        return ansArr.some((a) => valArr.includes(a));\r\n      case 'NOT IN':\r\n        return !ansArr.some((a) => valArr.includes(a));\r\n\r\n      default:\r\n        return false;\r\n    }\r\n  }\r\n\r\n  addGridsFromSubform(subform: any): void {\r\n    if (!subform || !Array.isArray(subform.rows)) return;\r\n\r\n    for (const row of subform.rows) {\r\n      if (!row.grid || !Array.isArray(row.grid)) continue;\r\n\r\n      for (const grid of row.grid) {\r\n        // 1️⃣ Add this grid itself if it has an active whenClause\r\n        this.addGrid(grid);\r\n\r\n        // 2️⃣ Then, recursively process nested childLogics inside its element\r\n        if (grid.element?.childLogics?.length) {\r\n          this.processChildLogics(grid.element.childLogics);\r\n        }\r\n      }\r\n    }\r\n  }\r\n\r\n  /**\r\n   * Recursively process childLogics structure\r\n   */\r\n  private processChildLogics(childLogics: any[]): void {\r\n    if (!Array.isArray(childLogics)) return;\r\n\r\n    for (const logic of childLogics) {\r\n      // 1️⃣ Each logic may have its own rows (similar to subform rows)\r\n      if (Array.isArray(logic.rows)) {\r\n        for (const row of logic.rows) {\r\n          if (Array.isArray(row.grid)) {\r\n            for (const grid of row.grid) {\r\n              // Check whenClause for this nested grid\r\n              this.addGrid(grid);\r\n\r\n              // 2️⃣ Recurse again if this nested question also has its own childLogics\r\n              if (grid.element?.childLogics?.length) {\r\n                this.processChildLogics(grid.element.childLogics);\r\n              }\r\n            }\r\n          }\r\n        }\r\n      }\r\n\r\n      // 3️⃣ A logic itself might directly contain nested logics\r\n      if (Array.isArray(logic.childLogics)) {\r\n        this.processChildLogics(logic.childLogics);\r\n      }\r\n    }\r\n  }\r\n\r\n  /**\r\n   * Return ALL elements with an active whenClause inside a subform,\r\n   * including nested childLogics (recursive)\r\n   */\r\n  getWhenClauseElements(subform: any): any[] {\r\n    const result: any[] = [];\r\n\r\n    if (!subform || !Array.isArray(subform.rows)) {\r\n      return result;\r\n    }\r\n\r\n    for (const row of subform.rows) {\r\n      if (!Array.isArray(row.grid)) continue;\r\n\r\n      for (const grid of row.grid) {\r\n        // 1️⃣ Add this grid if it has an active whenClause\r\n        if (this.isActiveWhenClause(grid)) {\r\n          result.push(grid);\r\n        }\r\n\r\n        // 2️⃣ Process nested childLogics inside this element\r\n        if (Array.isArray(grid.element?.childLogics)) {\r\n          result.push(\r\n            ...this.getElementsFromChildLogics(grid.element.childLogics)\r\n          );\r\n        }\r\n      }\r\n    }\r\n\r\n    return result;\r\n  }\r\n\r\n  /**\r\n   * Recursively gather grids with active whenClause inside childLogics\r\n   */\r\n  private getElementsFromChildLogics(childLogics: any[]): any[] {\r\n    const found: any[] = [];\r\n\r\n    if (!Array.isArray(childLogics)) return found;\r\n\r\n    for (const logic of childLogics) {\r\n      // Each logic can have rows\r\n      if (Array.isArray(logic.rows)) {\r\n        for (const row of logic.rows) {\r\n          if (!Array.isArray(row.grid)) continue;\r\n\r\n          for (const grid of row.grid) {\r\n            if (this.isActiveWhenClause(grid)) {\r\n              found.push(grid);\r\n            }\r\n\r\n            // Recurse deeper if this grid has nested childLogics\r\n            if (Array.isArray(grid.element?.childLogics)) {\r\n              found.push(\r\n                ...this.getElementsFromChildLogics(grid.element.childLogics)\r\n              );\r\n            }\r\n          }\r\n        }\r\n      }\r\n\r\n      // Logic itself may have nested childLogics\r\n      if (Array.isArray(logic.childLogics)) {\r\n        found.push(...this.getElementsFromChildLogics(logic.childLogics));\r\n      }\r\n    }\r\n\r\n    return found;\r\n  }\r\n\r\n  checkElementVisibility(id: string, submission: Submission): boolean {\r\n    if (!id || !submission || !Array.isArray(submission.answers)) {\r\n      return true; // default visible if invalid input\r\n    }\r\n\r\n    const matchedAnswer = submission.answers.find(\r\n      (ans) => ans.questionId === id\r\n    );\r\n\r\n    // Return the 'show' flag if found, else default to true\r\n    return matchedAnswer ? matchedAnswer.show ?? true : true;\r\n  }\r\n\r\n  evaluateSubformWhenClauses(\r\n    changedAnswer: any,\r\n    submission: Submission,\r\n    changedQuestionId: string,\r\n    elementsWithWhenClause: any\r\n  ) {\r\n    if (!elementsWithWhenClause.length) return;\r\n\r\n    for (const grid of elementsWithWhenClause) {\r\n      const elementId = grid.element.id;\r\n      const when = grid.whenClause;\r\n      const conditions = when.whenClauseCondition;\r\n\r\n      if (!conditions?.length) continue;\r\n\r\n      let overallResult = true;\r\n\r\n      for (let i = 0; i < conditions.length; i++) {\r\n        const clause = conditions[i];\r\n\r\n        const logic = (clause.logic || (i === 0 ? 'AND' : 'AND')).toUpperCase();\r\n\r\n        // Determine which answer to use for this condition\r\n        let answerToCheck: any;\r\n\r\n        if (clause.questionid === changedQuestionId) {\r\n          // Use updated answer for the changed question\r\n          answerToCheck = changedAnswer;\r\n        } else {\r\n          // Fetch existing value from submission for other questions\r\n          const existing = submission.answers.find(\r\n            (a) => a.questionId === clause.questionid\r\n          );\r\n          answerToCheck = existing?.answer;\r\n        }\r\n\r\n        const result = this.evaluateCondition(\r\n          answerToCheck,\r\n          clause.condition,\r\n          clause.value\r\n        );\r\n\r\n        // Apply AND/OR logic\r\n        if (i === 0) {\r\n          overallResult = result;\r\n        } else {\r\n          overallResult =\r\n            logic === 'AND' ? overallResult && result : overallResult || result;\r\n        }\r\n      }\r\n\r\n      // Update show flag for the element controlled by this whenClause\r\n      const matchedAnswer = submission.answers.find(\r\n        (ans) => ans.questionId === elementId\r\n      );\r\n\r\n      const actions: string[] = Array.isArray(when?.whenClauseActions)\r\n    ? when.whenClauseActions.map(String)\r\n    : [];\r\n\r\n      // choose the decisive action (use last if multiple)\r\n      const action = actions.length > 0 ? actions[actions.length - 1] : undefined;\r\n\r\n\r\n      if (matchedAnswer) {\r\n        if (overallResult) {\r\n          // Condition(s) satisfied -> perform the action\r\n          switch (action) {\r\n            case 'SHOW':\r\n              matchedAnswer.show = true;\r\n              break;\r\n            case 'HIDE':\r\n              matchedAnswer.show = false;\r\n              break;\r\n            case 'MARK_AS_REQUIRED':\r\n              matchedAnswer.required = true;\r\n              break;\r\n            case 'MARK_AS_OPTIONAL':\r\n              matchedAnswer.required = false;\r\n              break;\r\n            default:\r\n              // no show/hide action — keep current behavior (you can choose default here)\r\n              // For safety, if no explicit action, we'll leave grid.show unchanged.\r\n              break;\r\n          }\r\n\r\n        } else {\r\n          // Condition(s) not satisfied -> revert the action's effect\r\n          switch (action) {\r\n            case 'SHOW':\r\n              // condition no longer true => hide (revert)\r\n              matchedAnswer.show = false;\r\n              break;\r\n            case 'HIDE':\r\n              // condition no longer true => show (revert)\r\n              matchedAnswer.show = true;\r\n              break;\r\n            case 'MARK_AS_REQUIRED':\r\n              matchedAnswer.required = false;\r\n              break;\r\n            case 'MARK_AS_OPTIONAL':\r\n              matchedAnswer.required = true;\r\n              break;\r\n            default:\r\n              // nothing to revert\r\n              break;\r\n          }\r\n        }\r\n      }\r\n\r\n\r\n\r\n\r\n      // if (matchedAnswer) {\r\n      //   matchedAnswer.show = overallResult;\r\n      // }\r\n    }\r\n  }\r\n\r\n  resetService(): void {\r\n    // Clear tracked grids\r\n    this.activeWhenClauseGrids = [];\r\n\r\n    // Clear stored question → answer map\r\n    this.questionAnswerMap = {};\r\n\r\n    // Reset visibility logic to initial state\r\n  }\r\n\r\n  getActiveWhenClauseGrids(): any[] {\r\n    return this.activeWhenClauseGrids;\r\n  }\r\n}\r\n"]}

package/esm2022/shared/shared.module.mjs

@@ -0,0 +1,97 @@
+import { NgModule } from '@angular/core';
+import { CommonModule } from '@angular/common';
+import { RecursiveLogicComponent } from '../question/recursive-logic/recursive-logic.component';
+import { QuestionComponent } from '../question/question/question.component';
+import { SubFormComponent } from '../question/sub-form/sub-form.component';
+import { FormElementsComponent } from '../question/form-elements/form-elements.component';
+import { FormFieldsModule } from '../form-fields/form-fields.module';
+import { MatDialogModule } from '@angular/material/dialog';
+import { MatTableModule } from '@angular/material/table';
+import { MatMenuModule } from '@angular/material/menu';
+import { MatIconModule } from '@angular/material/icon';
+import { MultipleSubformComponent } from '../question/multiple-subform/multiple-subform.component';
+import { SubmissionModalComponent } from '../sub-form/submission-modal/submission-modal.component';
+import { QuestionGroupComponent } from '../question/question-group/question-group.component';
+import { InlineMultipleSubformComponent } from '../question/inline-multiple-subform/inline-multiple-subform.component';
+import { MultifieldsComponent } from '../question/multifields/multifields.component';
+import { CardSubformComponent } from '../question/card-subform/card-subform.component';
+import { QuillModule } from 'ngx-quill';
+import { FormsModule } from '@angular/forms';
+import { NgbModule } from '@ng-bootstrap/ng-bootstrap';
+import * as i0 from "@angular/core";
+export class SharedModule {
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: SharedModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule }); }
+    static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "16.2.12", ngImport: i0, type: SharedModule, declarations: [RecursiveLogicComponent,
+            QuestionComponent,
+            SubFormComponent,
+            FormElementsComponent,
+            MultipleSubformComponent,
+            SubmissionModalComponent,
+            QuestionGroupComponent,
+            InlineMultipleSubformComponent,
+            MultifieldsComponent,
+            CardSubformComponent], imports: [CommonModule,
+            FormFieldsModule,
+            MatDialogModule,
+            MatTableModule,
+            MatMenuModule,
+            MatIconModule,
+            QuillModule,
+            FormsModule,
+            NgbModule], exports: [RecursiveLogicComponent,
+            QuestionComponent,
+            SubFormComponent,
+            FormElementsComponent,
+            QuestionGroupComponent,
+            InlineMultipleSubformComponent,
+            MultifieldsComponent,
+            CardSubformComponent] }); }
+    static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: SharedModule, imports: [CommonModule,
+            FormFieldsModule,
+            MatDialogModule,
+            MatTableModule,
+            MatMenuModule,
+            MatIconModule,
+            QuillModule,
+            FormsModule,
+            NgbModule] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: SharedModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    declarations: [
+                        RecursiveLogicComponent,
+                        QuestionComponent,
+                        SubFormComponent,
+                        FormElementsComponent,
+                        MultipleSubformComponent,
+                        SubmissionModalComponent,
+                        QuestionGroupComponent,
+                        InlineMultipleSubformComponent,
+                        MultifieldsComponent,
+                        CardSubformComponent
+                    ],
+                    imports: [
+                        CommonModule,
+                        FormFieldsModule,
+                        MatDialogModule,
+                        MatTableModule,
+                        MatMenuModule,
+                        MatIconModule,
+                        QuillModule,
+                        FormsModule,
+                        NgbModule
+                    ],
+                    exports: [
+                        RecursiveLogicComponent,
+                        QuestionComponent,
+                        SubFormComponent,
+                        FormElementsComponent,
+                        QuestionGroupComponent,
+                        InlineMultipleSubformComponent,
+                        MultifieldsComponent,
+                        CardSubformComponent
+                    ]
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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