@evlop/commons 1.0.261 → 1.0.263

package/dist/esm/src/edl/parser.test.js

@@ -1,217 +1,336 @@
 import parseEDL from './parser';
 import { expect } from 'chai';
 describe('parseEDL', () => {
-    it('should parse an EDL string with a single tag and no props', () => {
-        const edlString = '<div></div>';
-        const result = parseEDL(edlString, new Set());
-        expect(result).to.be.an('array').with.lengthOf(1);
-        expect(result[0].tag).to.equal('div');
-        expect(result[0].staticProps).to.deep.equal({});
-        expect(result[0].variableProps).to.deep.equal({});
-        expect(result[0].children).to.deep.equal([]);
-    });
-    it('should parse an EDL string with a single tag and static props', () => {
-        const edlString = '<div class="container" id="main"></div>';
-        const result = parseEDL(edlString, new Set());
-        expect(result).to.be.an('array').with.lengthOf(1);
-        expect(result[0].tag).to.equal('div');
-        expect(result[0].staticProps).to.deep.equal({ className: 'container', id: 'main' });
-        expect(result[0].variableProps).to.deep.equal({});
-        expect(result[0].children).to.deep.equal([]);
-    });
-    it('should parse an EDL string with inline expression interpolation', () => {
-        const edlString = '<Text>Hello {user.name}!</Text>';
-        const result = parseEDL(edlString, new Set(['user']));
-        expect(result).to.be.an('array').with.lengthOf(1);
-        expect(result[0].tag).to.equal('Text');
-        expect(result[0].children).to.be.an('array').with.lengthOf(3);
-        expect(result[0].children[0]).to.equal('Hello ');
-        expect(result[0].children[1]).to.be.a('function'); // The interpolated expression
-        expect(result[0].children[2]).to.equal('!');
-    });
-    it('should parse an EDL string with nested tags', () => {
-        const edlString = '<div><span>Hello World</span></div>';
-        const result = parseEDL(edlString, new Set());
-        expect(result).to.be.an('array').with.lengthOf(1);
-        expect(result[0].tag).to.equal('div');
-        expect(result[0].children).to.be.an('array').with.lengthOf(1);
-        expect(result[0].children[0].tag).to.equal('span');
-        expect(result[0].children[0].children).to.deep.equal(['Hello World']);
-    });
-    it('should parse an EDL string with dynamic props', () => {
-        const edlString = '<input type="text" value={state.value} />';
-        const additionalVariables = new Set(['state']);
-        const result = parseEDL(edlString, additionalVariables);
-        expect(result).to.be.an('array').with.lengthOf(1);
-        expect(result[0].tag).to.equal('input');
-        expect(result[0].staticProps).to.deep.equal({ type: 'text' });
-        expect(result[0].variableProps).to.have.property('value');
-        expect(result[0].variableProps.value).to.be.a('function');
-    });
-    it('should parse an EDL string with a script tag and extract variables', () => {
-        const edlString = `<Script>
-      const $var1 = 42;
-      let $var2 =  "";
-    </Script>`;
-        const result = parseEDL(edlString, new Set());
-        console.log(result);
-        expect(result).to.be.an('array').with.lengthOf(1);
-        expect(result[0].tag).to.equal('Script');
-        expect(result[0].variableProps).to.have.property(':function');
-        expect(result[0].variableProps[':function']).to.be.a('function');
-    });
-    it('should handle self-closing tags', () => {
-        const edlString = '<img src="image.png" />';
-        const result = parseEDL(edlString, new Set());
-        expect(result).to.be.an('array').with.lengthOf(1);
-        expect(result[0].tag).to.equal('img');
-        expect(result[0].staticProps).to.deep.equal({ src: 'image.png' });
-    });
-    it('should parse an EDL string with both static and dynamic props', () => {
-        const edlString = '<button class="btn" onClick={handleClick}>Click Me</button>';
-        const additionalVariables = new Set(['handleClick']);
-        const result = parseEDL(edlString, additionalVariables);
-        expect(result).to.be.an('array').with.lengthOf(1);
-        expect(result[0].tag).to.equal('button');
-        expect(result[0].staticProps).to.deep.equal({ className: 'btn' });
-        expect(result[0].variableProps).to.have.property('onClick');
-        expect(result[0].variableProps.onClick).to.be.a('function');
-        expect(result[0].children).to.deep.equal(['Click Me']);
-    });
-    it('should parse an EDL string with mixed content (text and elements)', () => {
-        const edlString = '<div>Text before <span>inline text</span> and after</div>';
-        const result = parseEDL(edlString, new Set());
-        expect(result).to.be.an('array').with.lengthOf(1);
-        expect(result[0].tag).to.equal('div');
-        expect(result[0].children).to.be.an('array').with.lengthOf(3);
-        expect(result[0].children[0]).to.equal('Text before ');
-        expect(result[0].children[1].tag).to.equal('span');
-        expect(result[0].children[1].children).to.deep.equal(['inline text']);
-        expect(result[0].children[2]).to.equal(' and after');
-    });
-    it('should identify shared props when they modify different object properties', () => {
-        const edlString = '<div style.color="red" style.width={width}></div>';
-        const result = parseEDL(edlString, new Set(['width']));
-        expect(result).to.be.an('array').with.lengthOf(1);
-        expect(result[0].tag).to.equal('div');
-        expect(result[0].staticProps).to.deep.equal({
-            style: { color: 'red' }
-        });
-        expect(result[0].variableProps).to.have.property('style.width');
-        expect(result[0].sharedPropNames).to.deep.equal(['style']);
-    });
-    it('should handle multiple shared object properties', () => {
-        const edlString = '<div style.color="red" style.width={width} style.height="100px" style.margin={margin}></div>';
-        const result = parseEDL(edlString, new Set(['width', 'margin']));
-        expect(result).to.be.an('array').with.lengthOf(1);
-        expect(result[0].tag).to.equal('div');
-        expect(result[0].staticProps).to.deep.equal({
-            style: {
-                color: 'red',
-                height: '100px'
-            }
-        });
-        expect(result[0].variableProps).to.have.keys('style.width', 'style.margin');
-        expect(result[0].sharedPropNames).to.deep.equal(['style']);
-    });
-    it('should handle mixed shared object properties and regular props', () => {
-        const edlString = '<div class="container" style.color="red" style.width={width} onClick={handleClick}></div>';
-        const result = parseEDL(edlString, new Set(['width', 'handleClick']));
-        expect(result).to.be.an('array').with.lengthOf(1);
-        expect(result[0].tag).to.equal('div');
-        expect(result[0].staticProps).to.deep.equal({
-            className: 'container',
-            style: { color: 'red' }
-        });
-        expect(result[0].variableProps).to.have.keys('style.width', 'onClick');
-        console.log(result[0].sharedPropNames);
-        expect(result[0].sharedPropNames).to.deep.equal(['style']);
-    });
-    it('should not mark props as shared when only static object properties exist', () => {
-        const edlString = '<div style.color="red" style.width="100px"></div>';
-        const result = parseEDL(edlString, new Set());
-        expect(result).to.be.an('array').with.lengthOf(1);
-        expect(result[0].tag).to.equal('div');
-        expect(result[0].staticProps).to.deep.equal({
-            style: {
-                color: 'red',
-                width: '100px'
-            }
-        });
-        expect(result[0].variableProps).to.deep.equal({});
-        expect(result[0].sharedPropNames).to.deep.equal([]);
-    });
-    it('should not mark props as shared when only dynamic object properties exist', () => {
-        const edlString = '<div style.color={color} style.width={width}></div>';
-        const result = parseEDL(edlString, new Set(['color', 'width']));
-        expect(result).to.be.an('array').with.lengthOf(1);
-        expect(result[0].tag).to.equal('div');
-        expect(result[0].staticProps).to.deep.equal({});
-        expect(result[0].variableProps).to.have.keys('style.color', 'style.width');
-        expect(result[0].sharedPropNames).to.deep.equal([]);
+    // Basic Parsing
+    describe('basic parsing', () => {
+        it('should parse an EDL string with a single tag and no props', () => {
+            const edlString = '<div></div>';
+            const result = parseEDL(edlString, new Set());
+            expect(result).to.be.an('array').with.lengthOf(1);
+            expect(result[0].tag).to.equal('div');
+            expect(result[0].staticProps).to.deep.equal({});
+            expect(result[0].variableProps).to.deep.equal({});
+            expect(result[0].children).to.deep.equal([]);
+        });
+        it('should parse an EDL string with a single tag and static props', () => {
+            const edlString = '<div class="container" id="main"></div>';
+            const result = parseEDL(edlString, new Set());
+            expect(result).to.be.an('array').with.lengthOf(1);
+            expect(result[0].tag).to.equal('div');
+            expect(result[0].staticProps).to.deep.equal({ className: 'container', id: 'main' });
+            expect(result[0].variableProps).to.deep.equal({});
+            expect(result[0].children).to.deep.equal([]);
+        });
+        it('should handle self-closing tags', () => {
+            const edlString = '<img src="image.png" />';
+            const result = parseEDL(edlString, new Set());
+            expect(result).to.be.an('array').with.lengthOf(1);
+            expect(result[0].tag).to.equal('img');
+            expect(result[0].staticProps).to.deep.equal({ src: 'image.png' });
+        });
     });
-    it('should parse an EDL string with static props only', () => {
-        const edlString = '<div class="container" id="main"></div>';
-        const result = parseEDL(edlString, new Set());
-        expect(result).to.be.an('array').with.lengthOf(1);
-        expect(result[0].tag).to.equal('div');
-        expect(result[0].staticProps).to.deep.equal({ className: 'container', id: 'main' });
-        expect(result[0].variableProps).to.deep.equal({});
-        expect(result[0].sharedPropNames).to.deep.equal([]);
+    // Children and Nested Elements
+    describe('children and nested elements', () => {
+        it('should parse an EDL string with inline expression interpolation', () => {
+            const edlString = '<Text>Hello {user.name}!</Text>';
+            const result = parseEDL(edlString, new Set(['user']));
+            expect(result).to.be.an('array').with.lengthOf(1);
+            expect(result[0].tag).to.equal('Text');
+            expect(result[0].children).to.be.an('array').with.lengthOf(3);
+            expect(result[0].children[0]).to.equal('Hello ');
+            expect(result[0].children[1]).to.be.a('function'); // The interpolated expression
+            expect(result[0].children[2]).to.equal('!');
+        });
+        it('should parse an EDL string with nested tags', () => {
+            const edlString = '<div><span>Hello World</span></div>';
+            const result = parseEDL(edlString, new Set());
+            expect(result).to.be.an('array').with.lengthOf(1);
+            expect(result[0].tag).to.equal('div');
+            expect(result[0].children).to.be.an('array').with.lengthOf(1);
+            expect(result[0].children[0].tag).to.equal('span');
+            expect(result[0].children[0].children).to.deep.equal(['Hello World']);
+        });
+        it('should parse an EDL string with mixed content (text and elements)', () => {
+            const edlString = '<div>Text before <span>inline text</span> and after</div>';
+            const result = parseEDL(edlString, new Set());
+            expect(result).to.be.an('array').with.lengthOf(1);
+            expect(result[0].tag).to.equal('div');
+            expect(result[0].children).to.be.an('array').with.lengthOf(3);
+            expect(result[0].children[0]).to.equal('Text before ');
+            expect(result[0].children[1].tag).to.equal('span');
+            expect(result[0].children[1].children).to.deep.equal(['inline text']);
+            expect(result[0].children[2]).to.equal(' and after');
+        });
     });
-    it('should parse an EDL string with dynamic props only', () => {
-        const edlString = '<input value={state.value} onChange={handleChange} />';
-        const additionalVariables = new Set(['state', 'handleChange']);
-        const result = parseEDL(edlString, additionalVariables);
-        expect(result).to.be.an('array').with.lengthOf(1);
-        expect(result[0].tag).to.equal('input');
-        expect(result[0].staticProps).to.deep.equal({});
-        expect(result[0].variableProps).to.have.all.keys('value', 'onChange');
-        expect(result[0].sharedPropNames).to.deep.equal([]);
+    // Props Handling
+    describe('props handling', () => {
+        describe('static props', () => {
+            it('should parse an EDL string with static props only', () => {
+                const edlString = '<div class="container" id="main"></div>';
+                const result = parseEDL(edlString, new Set());
+                expect(result).to.be.an('array').with.lengthOf(1);
+                expect(result[0].tag).to.equal('div');
+                expect(result[0].staticProps).to.deep.equal({ className: 'container', id: 'main' });
+                expect(result[0].variableProps).to.deep.equal({});
+                expect(result[0].sharedPropNames).to.deep.equal([]);
+            });
+            it('should parse static expressions in dynamic syntax as static values', () => {
+                const edlString = '<div value={123} text={"static"} bool={true}></div>';
+                const result = parseEDL(edlString, new Set());
+                expect(result).to.be.an('array').with.lengthOf(1);
+                expect(result[0].tag).to.equal('div');
+                expect(result[0].staticProps).to.deep.equal({
+                    value: 123,
+                    text: 'static',
+                    bool: true
+                });
+                expect(result[0].variableProps).to.deep.equal({});
+                expect(result[0].sharedPropNames).to.deep.equal([]);
+            });
+            it('should parse valueless attributes as boolean props', () => {
+                const edlString = '<input type="text" disabled required/>';
+                const result = parseEDL(edlString, new Set());
+                expect(result).to.be.an('array').with.lengthOf(1);
+                expect(result[0].tag).to.equal('input');
+                expect(result[0].staticProps).to.deep.equal({
+                    type: 'text',
+                    disabled: true,
+                    required: true
+                });
+                expect(result[0].variableProps).to.deep.equal({});
+                expect(result[0].sharedPropNames).to.deep.equal([]);
+            });
+        });
+        describe('dynamic props', () => {
+            it('should parse an EDL string with dynamic props', () => {
+                const edlString = '<input type="text" value={state.value} />';
+                const additionalVariables = new Set(['state']);
+                const result = parseEDL(edlString, additionalVariables);
+                expect(result).to.be.an('array').with.lengthOf(1);
+                expect(result[0].tag).to.equal('input');
+                expect(result[0].staticProps).to.deep.equal({ type: 'text' });
+                expect(result[0].variableProps).to.have.property('value');
+                expect(result[0].variableProps.value).to.be.a('function');
+            });
+            it('should parse an EDL string with dynamic props only', () => {
+                const edlString = '<input value={state.value} onChange={handleChange} />';
+                const additionalVariables = new Set(['state', 'handleChange']);
+                const result = parseEDL(edlString, additionalVariables);
+                expect(result).to.be.an('array').with.lengthOf(1);
+                expect(result[0].tag).to.equal('input');
+                expect(result[0].staticProps).to.deep.equal({});
+                expect(result[0].variableProps).to.have.all.keys('value', 'onChange');
+                expect(result[0].sharedPropNames).to.deep.equal([]);
+            });
+        });
+        describe('mixed props', () => {
+            it('should parse an EDL string with both static and dynamic props', () => {
+                const edlString = '<button class="btn" onClick={handleClick}>Click Me</button>';
+                const additionalVariables = new Set(['handleClick']);
+                const result = parseEDL(edlString, additionalVariables);
+                expect(result).to.be.an('array').with.lengthOf(1);
+                expect(result[0].tag).to.equal('button');
+                expect(result[0].staticProps).to.deep.equal({ className: 'btn' });
+                expect(result[0].variableProps).to.have.property('onClick');
+                expect(result[0].sharedPropNames).to.deep.equal([]);
+                expect(result[0].children).to.deep.equal(['Click Me']);
+            });
+            it('should parse an EDL string with both static and dynamic props (not shared)', () => {
+                const edlString = '<button class="btn" onClick={handleClick}>Click Me</button>';
+                const additionalVariables = new Set(['handleClick']);
+                const result = parseEDL(edlString, additionalVariables);
+                expect(result).to.be.an('array').with.lengthOf(1);
+                expect(result[0].tag).to.equal('button');
+                expect(result[0].staticProps).to.deep.equal({ className: 'btn' });
+                expect(result[0].variableProps).to.have.property('onClick');
+                expect(result[0].sharedPropNames).to.deep.equal([]);
+                expect(result[0].children).to.deep.equal(['Click Me']);
+            });
+        });
     });
-    it('should parse an EDL string with both static and dynamic props (not shared)', () => {
-        const edlString = '<button class="btn" onClick={handleClick}>Click Me</button>';
-        const additionalVariables = new Set(['handleClick']);
-        const result = parseEDL(edlString, additionalVariables);
-        expect(result).to.be.an('array').with.lengthOf(1);
-        expect(result[0].tag).to.equal('button');
-        expect(result[0].staticProps).to.deep.equal({ className: 'btn' });
-        expect(result[0].variableProps).to.have.property('onClick');
-        expect(result[0].sharedPropNames).to.deep.equal([]);
-        expect(result[0].children).to.deep.equal(['Click Me']);
+    // Shared Props
+    describe('shared props', () => {
+        describe('basic shared props', () => {
+            it('should identify single shared prop correctly', () => {
+                const edlString = '<div class="static-class" class={dynamicClass}></div>';
+                const result = parseEDL(edlString, new Set(['dynamicClass']));
+                expect(result).to.be.an('array').with.lengthOf(1);
+                expect(result[0].tag).to.equal('div');
+                expect(result[0].staticProps).to.deep.equal({ className: 'static-class' });
+                expect(result[0].variableProps).to.have.property('className');
+                expect(result[0].sharedPropNames).to.deep.equal(['className']);
+            });
+            it('should handle multiple shared props correctly', () => {
+                const edlString = '<div id="static-id" class="static-class" id={dynamicId} class={dynamicClass}></div>';
+                const result = parseEDL(edlString, new Set(['dynamicId', 'dynamicClass']));
+                expect(result).to.be.an('array').with.lengthOf(1);
+                expect(result[0].tag).to.equal('div');
+                expect(result[0].staticProps).to.deep.equal({
+                    id: 'static-id',
+                    className: 'static-class'
+                });
+                expect(result[0].variableProps).to.have.keys('id', 'className');
+                expect(result[0].sharedPropNames).to.have.members(['id', 'className']);
+            });
+            it('should handle mixed shared and non-shared props', () => {
+                const edlString = '<div id="static-id" class="static-class" id={dynamicId} onClick={ () => console.log({ a: 123 }) }></div>';
+                const result = parseEDL(edlString, new Set(['dynamicId', 'handleClick']));
+                expect(result).to.be.an('array').with.lengthOf(1);
+                expect(result[0].tag).to.equal('div');
+                expect(result[0].staticProps).to.deep.equal({
+                    id: 'static-id',
+                    className: 'static-class'
+                });
+                expect(result[0].variableProps).to.have.keys('id', 'onClick');
+                expect(result[0].sharedPropNames).to.deep.equal(['id']);
+            });
+        });
+        describe('object properties', () => {
+            it('should identify shared props when they modify different object properties', () => {
+                const edlString = '<div style.color="red" style.width={width}></div>';
+                const result = parseEDL(edlString, new Set(['width']));
+                expect(result).to.be.an('array').with.lengthOf(1);
+                expect(result[0].tag).to.equal('div');
+                expect(result[0].staticProps).to.deep.equal({
+                    style: { color: 'red' }
+                });
+                expect(result[0].variableProps).to.have.property('style.width');
+                expect(result[0].sharedPropNames).to.deep.equal(['style']);
+            });
+            it('should handle multiple shared object properties', () => {
+                const edlString = '<div style.color="red" style.width={width} style.height="100px" style.margin={margin}></div>';
+                const result = parseEDL(edlString, new Set(['width', 'margin']));
+                expect(result).to.be.an('array').with.lengthOf(1);
+                expect(result[0].tag).to.equal('div');
+                expect(result[0].staticProps).to.deep.equal({
+                    style: {
+                        color: 'red',
+                        height: '100px'
+                    }
+                });
+                expect(result[0].variableProps).to.have.keys('style.width', 'style.margin');
+                expect(result[0].sharedPropNames).to.deep.equal(['style']);
+            });
+            it('should handle mixed shared object properties and regular props', () => {
+                const edlString = '<div class="container" style.color="red" style.width={width} onClick={handleClick}></div>';
+                const result = parseEDL(edlString, new Set(['width', 'handleClick']));
+                expect(result).to.be.an('array').with.lengthOf(1);
+                expect(result[0].tag).to.equal('div');
+                expect(result[0].staticProps).to.deep.equal({
+                    className: 'container',
+                    style: { color: 'red' }
+                });
+                expect(result[0].variableProps).to.have.keys('style.width', 'onClick');
+                console.log(result[0].sharedPropNames);
+                expect(result[0].sharedPropNames).to.deep.equal(['style']);
+            });
+            it('should not mark props as shared when only static object properties exist', () => {
+                const edlString = '<div style.color="red" style.width="100px"></div>';
+                const result = parseEDL(edlString, new Set());
+                expect(result).to.be.an('array').with.lengthOf(1);
+                expect(result[0].tag).to.equal('div');
+                expect(result[0].staticProps).to.deep.equal({
+                    style: {
+                        color: 'red',
+                        width: '100px'
+                    }
+                });
+                expect(result[0].variableProps).to.deep.equal({});
+                expect(result[0].sharedPropNames).to.deep.equal([]);
+            });
+            it('should not mark props as shared when only dynamic object properties exist', () => {
+                const edlString = '<div style.color={color} style.width={width}></div>';
+                const result = parseEDL(edlString, new Set(['color', 'width']));
+                expect(result).to.be.an('array').with.lengthOf(1);
+                expect(result[0].tag).to.equal('div');
+                expect(result[0].staticProps).to.deep.equal({});
+                expect(result[0].variableProps).to.have.keys('style.color', 'style.width');
+                expect(result[0].sharedPropNames).to.deep.equal([]);
+            });
+        });
     });
-    it('should identify single shared prop correctly', () => {
-        const edlString = '<div class="static-class" class={dynamicClass}></div>';
-        const result = parseEDL(edlString, new Set(['dynamicClass']));
-        expect(result).to.be.an('array').with.lengthOf(1);
-        expect(result[0].tag).to.equal('div');
-        expect(result[0].staticProps).to.deep.equal({ className: 'static-class' });
-        expect(result[0].variableProps).to.have.property('className');
-        expect(result[0].sharedPropNames).to.deep.equal(['className']);
+    // Script Tags
+    describe('script tags', () => {
+        it('should parse an EDL string with a script tag and extract variables', () => {
+            const edlString = `<Script>
+        const $var1 = 42;
+        let $var2 =  "";
+      </Script>`;
+            const result = parseEDL(edlString, new Set());
+            console.log(result);
+            expect(result).to.be.an('array').with.lengthOf(1);
+            expect(result[0].tag).to.equal('Script');
+            expect(result[0].variableProps).to.have.property(':function');
+            expect(result[0].variableProps[':function']).to.be.a('function');
+        });
     });
-    it('should handle multiple shared props correctly', () => {
-        const edlString = '<div id="static-id" class="static-class" id={dynamicId} class={dynamicClass}></div>';
-        const result = parseEDL(edlString, new Set(['dynamicId', 'dynamicClass']));
-        expect(result).to.be.an('array').with.lengthOf(1);
-        expect(result[0].tag).to.equal('div');
-        expect(result[0].staticProps).to.deep.equal({
-            id: 'static-id',
-            className: 'static-class'
-        });
-        expect(result[0].variableProps).to.have.keys('id', 'className');
-        expect(result[0].sharedPropNames).to.have.members(['id', 'className']);
+    // Expression Parsing
+    describe('expression parsing', () => {
+        it('should handle expressions containing string literals with braces', () => {
+            const edlString = '<div prop={`string with { braces }`}></div>';
+            const result = parseEDL(edlString, new Set());
+            expect(result).to.be.an('array').with.lengthOf(1);
+            expect(result[0].staticProps).to.deep.equal({ prop: 'string with { braces }' });
+        });
+        it('should handle nested expressions correctly', () => {
+            const edlString = '<div prop={{ nested: { value: 123 } }}></div>';
+            const result = parseEDL(edlString, new Set());
+            console.log(result);
+            expect(result).to.be.an('array').with.lengthOf(1);
+            expect(result[0].staticProps).to.deep.equal({ prop: { nested: { value: 123 } } });
+        });
+        it('should handle expressions with escaped quotes', () => {
+            const edlString = '<div prop={`string with \\`backticks\\` inside`}></div>';
+            const result = parseEDL(edlString, new Set());
+            expect(result).to.be.an('array').with.lengthOf(1);
+            expect(result[0].staticProps).to.deep.equal({ prop: 'string with `backticks` inside' });
+        });
+        it('should handle complex nested expressions with strings', () => {
+            const edlString = '<div prop={{ text: `Hello ${data.name}`, obj: { key: "{not an expression}" } }}></div>';
+            const result = parseEDL(edlString, new Set(['data']));
+            expect(result).to.be.an('array').with.lengthOf(1);
+            expect(result[0].variableProps).to.have.property('prop');
+            expect(result[0].variableProps.prop).to.be.a('function');
+        });
+        it('should handle expressions with function calls containing objects', () => {
+            const edlString = '<div onClick={() => handleClick({ id: 123 })}></div>';
+            const result = parseEDL(edlString, new Set(['handleClick']));
+            expect(result).to.be.an('array').with.lengthOf(1);
+            expect(result[0].variableProps).to.have.property('onClick');
+            expect(result[0].variableProps.onClick).to.be.a('function');
+        });
     });
-    it('should handle mixed shared and non-shared props', () => {
-        const edlString = '<div id="static-id" class="static-class" id={dynamicId} onClick={handleClick}></div>';
-        const result = parseEDL(edlString, new Set(['dynamicId', 'handleClick']));
-        expect(result).to.be.an('array').with.lengthOf(1);
-        expect(result[0].tag).to.equal('div');
-        expect(result[0].staticProps).to.deep.equal({
-            id: 'static-id',
-            className: 'static-class'
-        });
-        expect(result[0].variableProps).to.have.keys('id', 'onClick');
-        expect(result[0].sharedPropNames).to.deep.equal(['id']);
+    // Performance Testing
+    describe('performance testing', () => {
+        it('should handle parsing large EDL strings efficiently', () => {
+            // Generate EDL strings of different lengths
+            const generateEDL = (length) => {
+                const baseElement = '<div class="item" data-index={index}>Item {index}</div>';
+                const repeats = Math.ceil(length / baseElement.length);
+                return Array(repeats).fill(baseElement).join('').slice(0, length);
+            };
+            const testSizes = [100, 1000, 5000, 10000];
+            const results = [];
+            testSizes.forEach(size => {
+                const edlString = generateEDL(size);
+                const start = performance.now();
+                const result = parseEDL(edlString, new Set(['index']));
+                const end = performance.now();
+                results.push({ size, time: end - start });
+                // Basic validation of parsed output
+                expect(result).to.be.an('array');
+                expect(result.length).to.be.above(0);
+                expect(result[0].tag).to.equal('div');
+            });
+            // Log performance results
+            console.table(results);
+            // Ensure parsing time scales reasonably (not exponentially)
+            const [first, last] = [results[0], results[results.length - 1]];
+            const timeRatio = last.time / first.time;
+            const sizeRatio = last.size / first.size;
+            // Time increase should be less than cubic of size increase
+            expect(timeRatio).to.be.below(Math.pow(sizeRatio, 3));
+        });
     });
 });
 //# sourceMappingURL=parser.test.js.map