@wavemaker/react-codegen 11.14.2-1.245 → 12.0.0-next.28533

package/src/utils.test.js

@@ -0,0 +1,703 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const utils_1 = require("./utils");
+describe("addOptionalChainingToPropertyPath", () => {
+    // Basic property paths
+    describe("Basic property paths", () => {
+        const basicTests = [
+            { input: "a", expected: "a" },
+            { input: "a.b", expected: "a?.b" },
+            { input: "a.b.c", expected: "a?.b?.c" },
+            { input: "a.b.c.d", expected: "a?.b?.c?.d" },
+            { input: "a.b.c.d.e", expected: "a?.b?.c?.d?.e" },
+            { input: "Variables", expected: "Variables" },
+            { input: "Variables.data", expected: "Variables?.data" },
+            { input: "Variables.data.value", expected: "Variables?.data?.value" },
+            { input: "Widgets", expected: "Widgets" },
+            { input: "Widgets.form", expected: "Widgets?.form" },
+            { input: "Widgets.form.value", expected: "Widgets?.form?.value" },
+            { input: "Props", expected: "Props" },
+            { input: "Props.key", expected: "Props?.key" },
+            { input: "fragment", expected: "fragment" },
+            { input: "fragment.data", expected: "fragment?.data" },
+        ];
+        test.each(basicTests)("should handle basic path: $input", ({ input, expected }) => {
+            expect((0, utils_1.addOptionalChainingToPropertyPath)(input)).toBe(expected);
+        });
+    });
+    // Bracket notation with numeric indices
+    describe("Bracket notation with numeric indices", () => {
+        const numericIndexTests = [
+            { input: "items[0]", expected: "items?.[0]" },
+            { input: "items[1]", expected: "items?.[1]" },
+            { input: "items[0].name", expected: "items?.[0]?.name" },
+            { input: "items[1].value", expected: "items?.[1]?.value" },
+            { input: "data[0][1]", expected: "data?.[0]?.[1]" },
+            { input: "matrix[0][1][2]", expected: "matrix?.[0]?.[1]?.[2]" },
+            { input: "arr[0].prop[1].nested", expected: "arr?.[0]?.prop?.[1]?.nested" },
+            { input: "Variables.list[0]", expected: "Variables?.list?.[0]" },
+            { input: "Variables.list[0].id", expected: "Variables?.list?.[0]?.id" },
+            { input: "Widgets.grid[0][1]", expected: "Widgets?.grid?.[0]?.[1]" },
+        ];
+        test.each(numericIndexTests)("should handle numeric index: $input", ({ input, expected }) => {
+            expect((0, utils_1.addOptionalChainingToPropertyPath)(input)).toBe(expected);
+        });
+    });
+    // Bracket notation with string literals
+    describe("Bracket notation with string literals", () => {
+        const stringLiteralTests = [
+            { input: `user['name']`, expected: `user?.['name']` },
+            { input: `user["name"]`, expected: `user?.["name"]` },
+            { input: `user['first_name']`, expected: `user?.['first_name']` },
+            { input: `user["last-name"]`, expected: `user?.["last-name"]` },
+            { input: `data['key'].value`, expected: `data?.['key']?.value` },
+            { input: `obj["prop"]["nested"]`, expected: `obj?.["prop"]?.["nested"]` },
+            { input: `Variables['key']`, expected: `Variables?.['key']` },
+            { input: `Variables['key'].value`, expected: `Variables?.['key']?.value` },
+            { input: `Widgets['form']['field']`, expected: `Widgets?.['form']?.['field']` },
+            { input: `data['property_dataset']`, expected: `data?.['property_dataset']` },
+        ];
+        test.each(stringLiteralTests)("should handle string literal: $input", ({ input, expected }) => {
+            expect((0, utils_1.addOptionalChainingToPropertyPath)(input)).toBe(expected);
+        });
+    });
+    // Bracket notation with property paths (the main fix)
+    describe("Bracket notation with property paths inside", () => {
+        const propertyPathInBracketTests = [
+            {
+                input: "data[Widgets.form.value]",
+                expected: "data?.[Widgets?.form?.value]",
+            },
+            {
+                input: "Variables.data[Widgets.form.value]",
+                expected: "Variables?.data?.[Widgets?.form?.value]",
+            },
+            {
+                input: "items[Variables.selectedIndex]",
+                expected: "items?.[Variables?.selectedIndex]",
+            },
+            {
+                input: "data[Widgets.form.value].id",
+                expected: "data?.[Widgets?.form?.value]?.id",
+            },
+            {
+                input: "Variables.stvWidgetToFieldMappings.dataSet[Widgets.editFormMetaDataForm1.formWidgets.FormMetaData_widget.datavalue]",
+                expected: "Variables?.stvWidgetToFieldMappings?.dataSet?.[Widgets?.editFormMetaDataForm1?.formWidgets?.FormMetaData_widget?.datavalue]",
+            },
+            {
+                input: "Variables.stvWidgetToFieldMappings.dataSet[Widgets.editFormMetaDataForm1.formWidgets.FormMetaData_widget.datavalue]['property_dataset']",
+                expected: "Variables?.stvWidgetToFieldMappings?.dataSet?.[Widgets?.editFormMetaDataForm1?.formWidgets?.FormMetaData_widget?.datavalue]?.['property_dataset']",
+            },
+            {
+                input: "grid[Widgets.form.selectedRow].id",
+                expected: "grid?.[Widgets?.form?.selectedRow]?.id",
+            },
+            {
+                input: "data[Props.key][Props.nested]",
+                expected: "data?.[Props?.key]?.[Props?.nested]",
+            },
+            {
+                input: "Variables.list[Widgets.dropdown.selectedValue]",
+                expected: "Variables?.list?.[Widgets?.dropdown?.selectedValue]",
+            },
+            {
+                input: "obj[Variables.key1][Variables.key2].prop",
+                expected: "obj?.[Variables?.key1]?.[Variables?.key2]?.prop",
+            },
+        ];
+        test.each(propertyPathInBracketTests)("should handle property path in bracket: $input", ({ input, expected }) => {
+            expect((0, utils_1.addOptionalChainingToPropertyPath)(input)).toBe(expected);
+        });
+    });
+    // Mixed scenarios
+    describe("Mixed scenarios", () => {
+        const mixedTests = [
+            {
+                input: "data[0].items[Widgets.form.value].name",
+                expected: "data?.[0]?.items?.[Widgets?.form?.value]?.name",
+            },
+            {
+                input: "Variables.list[Widgets.grid.selectedIndex]['status']",
+                expected: "Variables?.list?.[Widgets?.grid?.selectedIndex]?.['status']",
+            },
+            {
+                input: "obj['key'][Variables.index].prop[Props.id]",
+                expected: "obj?.['key']?.[Variables?.index]?.prop?.[Props?.id]",
+            },
+            {
+                input: "data[Widgets.form.value][0]['name']",
+                expected: "data?.[Widgets?.form?.value]?.[0]?.['name']",
+            },
+            {
+                input: "matrix[Variables.row][Variables.col].value",
+                expected: "matrix?.[Variables?.row]?.[Variables?.col]?.value",
+            },
+        ];
+        test.each(mixedTests)("should handle mixed scenario: $input", ({ input, expected }) => {
+            expect((0, utils_1.addOptionalChainingToPropertyPath)(input)).toBe(expected);
+        });
+    });
+    // Nested brackets
+    describe("Nested brackets", () => {
+        const nestedBracketTests = [
+            { input: "data[items[0]]", expected: "data?.[items[0]]" },
+            { input: "data[items[0]].value", expected: "data?.[items[0]]?.value" },
+            { input: "matrix[rows[0]][cols[1]]", expected: "matrix?.[rows[0]]?.[cols[1]]" },
+            { input: "obj[data[Widgets.form.key]]", expected: "obj?.[data[Widgets?.form?.key]]" },
+            { input: "data[items[Variables.index]]", expected: "data?.[items[Variables?.index]]" },
+        ];
+        test.each(nestedBracketTests)("should handle nested brackets: $input", ({ input, expected }) => {
+            expect((0, utils_1.addOptionalChainingToPropertyPath)(input)).toBe(expected);
+        });
+    });
+    // Edge cases
+    describe("Edge cases", () => {
+        const edgeCaseTests = [
+            { input: "", expected: "" },
+            { input: "a", expected: "a" },
+            { input: "_", expected: "_" },
+            { input: "$", expected: "$" },
+            { input: "_$", expected: "_$" },
+            { input: "a_b", expected: "a_b" },
+            { input: "a$b", expected: "a$b" },
+            { input: "a1", expected: "a1" },
+            { input: "a1.b2", expected: "a1?.b2" },
+            { input: "a_b.c_d", expected: "a_b?.c_d" },
+            { input: "a$b.c$d", expected: "a$b?.c$d" },
+        ];
+        test.each(edgeCaseTests)("should handle edge case: $input", ({ input, expected }) => {
+            expect((0, utils_1.addOptionalChainingToPropertyPath)(input)).toBe(expected);
+        });
+    });
+    // Generate hundreds of variations programmatically
+    describe("Generated test cases - Basic variations", () => {
+        const prefixes = ["Variables", "Widgets", "Props", "fragment", "data", "obj", "items"];
+        const properties = ["value", "data", "id", "name", "key", "selected", "form", "grid"];
+        const indices = [0, 1, 2, 10, 100];
+        const stringKeys = ["key", "name", "id", "value", "property_dataset", "first_name"];
+        // Generate 200+ basic property path tests
+        const generatedBasicTests = [];
+        for (const prefix of prefixes) {
+            for (const prop of properties) {
+                generatedBasicTests.push({
+                    input: `${prefix}.${prop}`,
+                    expected: `${prefix}?.${prop}`,
+                });
+                for (const prop2 of properties.slice(0, 3)) {
+                    generatedBasicTests.push({
+                        input: `${prefix}.${prop}.${prop2}`,
+                        expected: `${prefix}?.${prop}?.${prop2}`,
+                    });
+                }
+            }
+        }
+        test.each(generatedBasicTests)("generated basic: $input", ({ input, expected }) => {
+            expect((0, utils_1.addOptionalChainingToPropertyPath)(input)).toBe(expected);
+        });
+    });
+    describe("Generated test cases - Bracket with numeric indices", () => {
+        const prefixes = ["Variables", "Widgets", "data", "items", "arr"];
+        const properties = ["list", "items", "data", "array", "grid"];
+        const indices = [0, 1, 2, 5, 10, 99, 100];
+        const generatedNumericTests = [];
+        for (const prefix of prefixes) {
+            for (const prop of properties) {
+                for (const idx of indices) {
+                    generatedNumericTests.push({
+                        input: `${prefix}.${prop}[${idx}]`,
+                        expected: `${prefix}?.${prop}?.[${idx}]`,
+                    });
+                    generatedNumericTests.push({
+                        input: `${prefix}.${prop}[${idx}].id`,
+                        expected: `${prefix}?.${prop}?.[${idx}]?.id`,
+                    });
+                }
+            }
+        }
+        test.each(generatedNumericTests)("generated numeric: $input", ({ input, expected }) => {
+            expect((0, utils_1.addOptionalChainingToPropertyPath)(input)).toBe(expected);
+        });
+    });
+    describe("Generated test cases - Bracket with string literals", () => {
+        const prefixes = ["Variables", "Widgets", "data", "obj"];
+        const properties = ["data", "form", "grid", "list"];
+        const stringKeys = [
+            "key",
+            "name",
+            "id",
+            "value",
+            "property_dataset",
+            "first_name",
+            "last-name",
+        ];
+        const generatedStringTests = [];
+        for (const prefix of prefixes) {
+            for (const prop of properties) {
+                for (const key of stringKeys) {
+                    generatedStringTests.push({
+                        input: `${prefix}.${prop}['${key}']`,
+                        expected: `${prefix}?.${prop}?.['${key}']`,
+                    });
+                    generatedStringTests.push({
+                        input: `${prefix}.${prop}["${key}"]`,
+                        expected: `${prefix}?.${prop}?.["${key}"]`,
+                    });
+                }
+            }
+        }
+        test.each(generatedStringTests)("generated string literal: $input", ({ input, expected }) => {
+            expect((0, utils_1.addOptionalChainingToPropertyPath)(input)).toBe(expected);
+        });
+    });
+    describe("Generated test cases - Property paths in brackets", () => {
+        const outerPrefixes = ["Variables", "data", "obj", "items"];
+        const outerProps = ["dataSet", "list", "items", "grid", "form"];
+        const innerPrefixes = ["Widgets", "Variables", "Props"];
+        const innerProps = ["form", "grid", "dropdown", "list"];
+        const innerValues = ["value", "selectedValue", "selectedIndex", "datavalue"];
+        const generatedPropertyPathTests = [];
+        for (const outerPrefix of outerPrefixes) {
+            for (const outerProp of outerProps) {
+                for (const innerPrefix of innerPrefixes) {
+                    for (const innerProp of innerProps) {
+                        for (const innerValue of innerValues) {
+                            generatedPropertyPathTests.push({
+                                input: `${outerPrefix}.${outerProp}[${innerPrefix}.${innerProp}.${innerValue}]`,
+                                expected: `${outerPrefix}?.${outerProp}?.[${innerPrefix}?.${innerProp}?.${innerValue}]`,
+                            });
+                        }
+                    }
+                }
+            }
+        }
+        test.each(generatedPropertyPathTests)("generated property path in bracket: $input", ({ input, expected }) => {
+            expect((0, utils_1.addOptionalChainingToPropertyPath)(input)).toBe(expected);
+        });
+    });
+    describe("Generated test cases - Complex nested scenarios", () => {
+        const basePaths = ["Variables", "Widgets", "data"];
+        const middleProps = ["dataSet", "list", "items"];
+        const innerPaths = ["Widgets.form.value", "Variables.selectedIndex", "Props.key"];
+        const finalProps = ["id", "name", "value"];
+        const stringKeys = ["property_dataset", "key", "name"];
+        const generatedComplexTests = [];
+        for (const base of basePaths) {
+            for (const middle of middleProps) {
+                for (const inner of innerPaths) {
+                    // Test with property path in bracket + final property
+                    generatedComplexTests.push({
+                        input: `${base}.${middle}[${inner}].id`,
+                        expected: `${base}?.${middle}?.[${inner.split(".").join("?.")}]?.id`,
+                    });
+                    // Test with property path in bracket + string key
+                    for (const key of stringKeys) {
+                        generatedComplexTests.push({
+                            input: `${base}.${middle}[${inner}]['${key}']`,
+                            expected: `${base}?.${middle}?.[${inner.split(".").join("?.")}]?.['${key}']`,
+                        });
+                    }
+                }
+            }
+        }
+        test.each(generatedComplexTests)("generated complex: $input", ({ input, expected }) => {
+            expect((0, utils_1.addOptionalChainingToPropertyPath)(input)).toBe(expected);
+        });
+    });
+    describe("Generated test cases - Multiple bracket accesses", () => {
+        const prefixes = ["Variables", "data", "obj"];
+        const props = ["data", "list", "items"];
+        const bracket1 = ["Widgets.form.value", "Variables.index", "0", "'key'"];
+        const bracket2 = ["Props.id", "Widgets.selected", "1", "'name'"];
+        const generatedMultipleBracketTests = [];
+        for (const prefix of prefixes) {
+            for (const prop of props) {
+                for (const b1 of bracket1) {
+                    for (const b2 of bracket2) {
+                        const b1Processed = b1.includes(".") ? b1.split(".").join("?.") : b1;
+                        const b2Processed = b2.includes(".") ? b2.split(".").join("?.") : b2;
+                        generatedMultipleBracketTests.push({
+                            input: `${prefix}.${prop}[${b1}][${b2}]`,
+                            expected: `${prefix}?.${prop}?.[${b1Processed}]?.[${b2Processed}]`,
+                        });
+                    }
+                }
+            }
+        }
+        test.each(generatedMultipleBracketTests)("generated multiple brackets: $input", ({ input, expected }) => {
+            expect((0, utils_1.addOptionalChainingToPropertyPath)(input)).toBe(expected);
+        });
+    });
+    // Real-world scenarios from WaveMaker
+    describe("Real-world WaveMaker scenarios", () => {
+        const realWorldTests = [
+            {
+                input: "Variables.stvWidgetToFieldMappings.dataSet[Widgets.editFormMetaDataForm1.formWidgets.FormMetaData_widget.datavalue]['property_dataset']",
+                expected: "Variables?.stvWidgetToFieldMappings?.dataSet?.[Widgets?.editFormMetaDataForm1?.formWidgets?.FormMetaData_widget?.datavalue]?.['property_dataset']",
+            },
+            {
+                input: "Widgets.dataGrid1.selecteditem[Variables.selectedRowIndex].id",
+                expected: "Widgets?.dataGrid1?.selecteditem?.[Variables?.selectedRowIndex]?.id",
+            },
+            {
+                input: "Variables.userList[Widgets.userDropdown.selectedValue].email",
+                expected: "Variables?.userList?.[Widgets?.userDropdown?.selectedValue]?.email",
+            },
+            {
+                input: "Widgets.form1.formWidgets.name_widget.datavalue",
+                expected: "Widgets?.form1?.formWidgets?.name_widget?.datavalue",
+            },
+            {
+                input: "Variables.data[Widgets.grid.selectedRow][Props.columnKey]",
+                expected: "Variables?.data?.[Widgets?.grid?.selectedRow]?.[Props?.columnKey]",
+            },
+            {
+                input: "fragment.Variables.localData[Widgets.localForm.value].id",
+                expected: "fragment?.Variables?.localData?.[Widgets?.localForm?.value]?.id",
+            },
+        ];
+        test.each(realWorldTests)("real-world scenario: $input", ({ input, expected }) => {
+            expect((0, utils_1.addOptionalChainingToPropertyPath)(input)).toBe(expected);
+        });
+    });
+});
+describe("addOptionalChaining", () => {
+    describe("Basic functionality", () => {
+        const basicTests = [
+            { input: "Variables.data.value", expected: "Variables?.data?.value" },
+            { input: "Widgets.form.selected", expected: "Widgets?.form?.selected" },
+            { input: "data[0].name", expected: "data?.[0]?.name" },
+            { input: `user['name']`, expected: `user?.['name']` },
+            {
+                input: "data[Widgets.form.value]",
+                expected: "data?.[Widgets?.form?.value]",
+            },
+        ];
+        test.each(basicTests)("should add optional chaining: $input", ({ input, expected }) => {
+            expect((0, utils_1.addOptionalChaining)(input)).toBe(expected);
+        });
+    });
+    describe("With fallback", () => {
+        const fallbackTests = [
+            {
+                input: "Variables.data.value",
+                expected: '(Variables?.data?.value || "")',
+                options: { addFallback: true },
+            },
+            {
+                input: "Widgets.form.selected",
+                expected: '(Widgets?.form?.selected || "")',
+                options: { addFallback: true, fallbackValue: '""' },
+            },
+            {
+                input: "data[Widgets.form.value]",
+                expected: '(data?.[Widgets?.form?.value] || "")',
+                options: { addFallback: true },
+            },
+            {
+                input: "Variables.data.value",
+                expected: "(Variables?.data?.value || null)",
+                options: { addFallback: true, fallbackValue: "null" },
+            },
+        ];
+        test.each(fallbackTests)("should add fallback: $input", ({ input, expected, options }) => {
+            expect((0, utils_1.addOptionalChaining)(input, options)).toBe(expected);
+        });
+    });
+    describe("With string literals", () => {
+        const stringLiteralTests = [
+            {
+                input: `Variables.data["key"].value`,
+                expected: `Variables?.data?.["key"]?.value`,
+            },
+            {
+                input: `data['name'].id`,
+                expected: `data?.['name']?.id`,
+            },
+            {
+                input: `obj["prop"]['nested']`,
+                expected: `obj?.["prop"]?.['nested']`,
+            },
+        ];
+        test.each(stringLiteralTests)("should preserve string literals: $input", ({ input, expected }) => {
+            expect((0, utils_1.addOptionalChaining)(input)).toBe(expected);
+        });
+    });
+    describe("Complex expressions", () => {
+        const complexTests = [
+            {
+                input: "Variables.stvWidgetToFieldMappings.dataSet[Widgets.editFormMetaDataForm1.formWidgets.FormMetaData_widget.datavalue]['property_dataset']",
+                expected: "Variables?.stvWidgetToFieldMappings?.dataSet?.[Widgets?.editFormMetaDataForm1?.formWidgets?.FormMetaData_widget?.datavalue]?.['property_dataset']",
+            },
+            {
+                input: "data[Widgets.form.value][Variables.index].id",
+                expected: "data?.[Widgets?.form?.value]?.[Variables?.index]?.id",
+            },
+            {
+                input: "Variables.list[Widgets.grid.selectedRow][Props.columnKey]['status']",
+                expected: "Variables?.list?.[Widgets?.grid?.selectedRow]?.[Props?.columnKey]?.['status']",
+            },
+        ];
+        test.each(complexTests)("should handle complex expression: $input", ({ input, expected }) => {
+            expect((0, utils_1.addOptionalChaining)(input)).toBe(expected);
+        });
+    });
+    // Generate thousands of test cases for addOptionalChaining
+    describe("Generated test cases - Large scale", () => {
+        const prefixes = ["Variables", "Widgets", "Props", "data", "obj"];
+        const props = ["data", "list", "items", "form", "grid"];
+        const bracketValues = [
+            "Widgets.form.value",
+            "Variables.index",
+            "Props.key",
+            "0",
+            "1",
+            "'key'",
+            '"name"',
+        ];
+        const finalProps = ["id", "name", "value", "selected"];
+        const generatedLargeScaleTests = [];
+        // Generate 500+ variations
+        for (const prefix of prefixes) {
+            for (const prop of props) {
+                for (const bracket of bracketValues) {
+                    const bracketProcessed = bracket.includes(".") ? bracket.split(".").join("?.") : bracket;
+                    generatedLargeScaleTests.push({
+                        input: `${prefix}.${prop}[${bracket}]`,
+                        expected: `${prefix}?.${prop}?.[${bracketProcessed}]`,
+                    });
+                    for (const final of finalProps) {
+                        generatedLargeScaleTests.push({
+                            input: `${prefix}.${prop}[${bracket}].${final}`,
+                            expected: `${prefix}?.${prop}?.[${bracketProcessed}]?.${final}`,
+                        });
+                    }
+                }
+            }
+        }
+        test.each(generatedLargeScaleTests)("generated large scale: $input", ({ input, expected }) => {
+            expect((0, utils_1.addOptionalChaining)(input)).toBe(expected);
+        });
+    });
+    describe("Function calls", () => {
+        describe("Basic function calls", () => {
+            const basicFunctionTests = [
+                { input: "obj.method()", expected: "obj?.method()" },
+                { input: "Variables.data.getValue()", expected: "Variables?.data?.getValue()" },
+                { input: "Widgets.form.getSelected()", expected: "Widgets?.form?.getSelected()" },
+                { input: "obj.method().prop", expected: "obj?.method()?.prop" },
+                { input: "obj.method().prop.value", expected: "obj?.method()?.prop?.value" },
+                { input: "Variables.data.getValue().id", expected: "Variables?.data?.getValue()?.id" },
+            ];
+            test.each(basicFunctionTests)("should handle basic function call: $input", ({ input, expected }) => {
+                expect((0, utils_1.addOptionalChaining)(input)).toBe(expected);
+            });
+        });
+        describe("Function calls with arguments", () => {
+            const functionWithArgsTests = [
+                { input: "obj.method(arg1)", expected: "obj?.method(arg1)" },
+                { input: "obj.method(arg1, arg2)", expected: "obj?.method(arg1, arg2)" },
+                {
+                    input: "obj.method(Variables.data.value)",
+                    expected: "obj?.method(Variables?.data?.value)",
+                },
+                {
+                    input: "obj.method(Widgets.form.selected)",
+                    expected: "obj?.method(Widgets?.form?.selected)",
+                },
+                {
+                    input: "obj.method(Variables.data.value, Widgets.form.id)",
+                    expected: "obj?.method(Variables?.data?.value, Widgets?.form?.id)",
+                },
+                {
+                    input: "obj.method(Variables.data[Widgets.form.value])",
+                    expected: "obj?.method(Variables?.data?.[Widgets?.form?.value])",
+                },
+                { input: "obj.method().prop", expected: "obj?.method()?.prop" },
+                { input: "obj.method(arg1).prop", expected: "obj?.method(arg1)?.prop" },
+            ];
+            test.each(functionWithArgsTests)("should handle function with args: $input", ({ input, expected }) => {
+                expect((0, utils_1.addOptionalChaining)(input)).toBe(expected);
+            });
+        });
+        describe("Chained function calls", () => {
+            const chainedFunctionTests = [
+                { input: "obj.method1().method2()", expected: "obj?.method1()?.method2()" },
+                {
+                    input: "obj.method1().method2().method3()",
+                    expected: "obj?.method1()?.method2()?.method3()",
+                },
+                { input: "Variables.data.filter().map()", expected: "Variables?.data?.filter()?.map()" },
+                {
+                    input: "Variables.data.filter().map().reduce()",
+                    expected: "Variables?.data?.filter()?.map()?.reduce()",
+                },
+                { input: "obj.method1().method2().prop", expected: "obj?.method1()?.method2()?.prop" },
+                {
+                    input: "Variables.data.getValue().process().id",
+                    expected: "Variables?.data?.getValue()?.process()?.id",
+                },
+            ];
+            test.each(chainedFunctionTests)("should handle chained function calls: $input", ({ input, expected }) => {
+                expect((0, utils_1.addOptionalChaining)(input)).toBe(expected);
+            });
+        });
+        describe("Function calls with array methods", () => {
+            const arrayMethodTests = [
+                {
+                    input: "Variables.data.filter(item => item.id)",
+                    expected: "Variables?.data?.filter(item => item?.id)",
+                },
+                {
+                    input: "Variables.data.map(x => x.name)",
+                    expected: "Variables?.data?.map(x => x?.name)",
+                },
+                {
+                    input: "Variables.data.filter(item => item.id).map(x => x.name)",
+                    expected: "Variables?.data?.filter(item => item?.id)?.map(x => x?.name)",
+                },
+                {
+                    input: "Variables.list.filter(item => item.status === 'active')",
+                    expected: "Variables?.list?.filter(item => item?.status === 'active')",
+                },
+                {
+                    input: "Variables.data.reduce((acc, item) => acc + item.value, 0)",
+                    expected: "Variables?.data?.reduce((acc, item) => acc + item?.value, 0)",
+                },
+                {
+                    input: "Variables.data.find(item => item.id === Variables.selectedId)",
+                    expected: "Variables?.data?.find(item => item?.id === Variables?.selectedId)",
+                },
+            ];
+            test.each(arrayMethodTests)("should handle array methods: $input", ({ input, expected }) => {
+                expect((0, utils_1.addOptionalChaining)(input)).toBe(expected);
+            });
+        });
+        describe("Function calls inside brackets", () => {
+            const functionInBracketTests = [
+                { input: "data[obj.method()]", expected: "data?.[obj?.method()]" },
+                { input: "data[obj.method().prop]", expected: "data?.[obj?.method()?.prop]" },
+                { input: "data[Widgets.form.getValue()]", expected: "data?.[Widgets?.form?.getValue()]" },
+                { input: "Variables.list[obj.method()]", expected: "Variables?.list?.[obj?.method()]" },
+                {
+                    input: "data[Widgets.form.getValue()].getItem()",
+                    expected: "data?.[Widgets?.form?.getValue()]?.getItem()",
+                },
+                {
+                    input: "data[Widgets.form.getValue()].getItem().name",
+                    expected: "data?.[Widgets?.form?.getValue()]?.getItem()?.name",
+                },
+                {
+                    input: "Variables.list[obj.method()].prop",
+                    expected: "Variables?.list?.[obj?.method()]?.prop",
+                },
+            ];
+            test.each(functionInBracketTests)("should handle function in bracket: $input", ({ input, expected }) => {
+                expect((0, utils_1.addOptionalChaining)(input)).toBe(expected);
+            });
+        });
+        describe("Complex function call scenarios", () => {
+            const complexFunctionTests = [
+                {
+                    input: "data[Widgets.form.getValue()].getItem().name",
+                    expected: "data?.[Widgets?.form?.getValue()]?.getItem()?.name",
+                },
+                {
+                    input: "Variables.list[obj.method()].prop",
+                    expected: "Variables?.list?.[obj?.method()]?.prop",
+                },
+                {
+                    input: "obj.method(Variables.data[Widgets.form.value])",
+                    expected: "obj?.method(Variables?.data?.[Widgets?.form?.value])",
+                },
+                {
+                    input: "obj.method(Variables.data[Widgets.form.value]).prop",
+                    expected: "obj?.method(Variables?.data?.[Widgets?.form?.value])?.prop",
+                },
+                {
+                    input: "Variables.data.filter(item => item.id === Variables.selectedId).map(x => x.name)",
+                    expected: "Variables?.data?.filter(item => item?.id === Variables?.selectedId)?.map(x => x?.name)",
+                },
+                {
+                    input: "data[Widgets.form.getValue()][Variables.index].getItem()",
+                    expected: "data?.[Widgets?.form?.getValue()]?.[Variables?.index]?.getItem()",
+                },
+            ];
+            test.each(complexFunctionTests)("should handle complex function scenario: $input", ({ input, expected }) => {
+                expect((0, utils_1.addOptionalChaining)(input)).toBe(expected);
+            });
+        });
+        // Generate hundreds of function call variations
+        describe("Generated test cases - Function calls", () => {
+            const prefixes = ["Variables", "Widgets", "data", "obj"];
+            const props = ["data", "list", "items", "form"];
+            const methods = ["getValue", "getSelected", "getItem", "filter", "map", "find"];
+            const finalProps = ["id", "name", "value"];
+            const generatedFunctionTests = [];
+            // Generate function call tests
+            for (const prefix of prefixes) {
+                for (const prop of props) {
+                    for (const method of methods) {
+                        generatedFunctionTests.push({
+                            input: `${prefix}.${prop}.${method}()`,
+                            expected: `${prefix}?.${prop}?.${method}()`,
+                        });
+                        for (const final of finalProps) {
+                            generatedFunctionTests.push({
+                                input: `${prefix}.${prop}.${method}().${final}`,
+                                expected: `${prefix}?.${prop}?.${method}()?.${final}`,
+                            });
+                        }
+                    }
+                }
+            }
+            // Generate chained function calls
+            for (const prefix of prefixes.slice(0, 2)) {
+                for (const prop of props.slice(0, 2)) {
+                    for (const method1 of methods.slice(0, 3)) {
+                        for (const method2 of methods.slice(0, 3)) {
+                            generatedFunctionTests.push({
+                                input: `${prefix}.${prop}.${method1}().${method2}()`,
+                                expected: `${prefix}?.${prop}?.${method1}()?.${method2}()`,
+                            });
+                        }
+                    }
+                }
+            }
+            test.each(generatedFunctionTests)("generated function call: $input", ({ input, expected }) => {
+                expect((0, utils_1.addOptionalChaining)(input)).toBe(expected);
+            });
+        });
+    });
+    describe("Pipe expressions", () => {
+        const pipeTests = [
+            {
+                input: '(Variables.wsGetMobileDetails.dataSet.data[0].attachment | filter: {name: "productimage"})[0].url',
+                expected: '(Variables?.wsGetMobileDetails?.dataSet?.data?.[0]?.attachment | filter: {name: "productimage"})?.[0]?.url',
+            },
+            {
+                input: "(expr | pipe).prop",
+                expected: "(expr | pipe)?.prop",
+            },
+            {
+                input: "(expr | pipe)[0].prop",
+                expected: "(expr | pipe)?.[0]?.prop",
+            },
+            {
+                input: "(Variables.data | filter: {id: 1})[0].name",
+                expected: "(Variables?.data | filter: {id: 1})?.[0]?.name",
+            },
+            {
+                input: "(Variables.list | filter: {status: 'active'})[0].id",
+                expected: "(Variables?.list | filter: {status: 'active'})?.[0]?.id",
+            },
+            {
+                input: "(Widgets.form.data | custom: 'format')?.value",
+                expected: "(Widgets?.form?.data | custom: 'format')?.value",
+            },
+        ];
+        test.each(pipeTests)("should handle pipe expression: $input", ({ input, expected }) => {
+            expect((0, utils_1.addOptionalChaining)(input)).toBe(expected);
+        });
+    });
+});
+//# sourceMappingURL=utils.test.js.map