ripple 0.2.124 → 0.2.125

package/tests/server/if.test.ripple

@@ -63,4 +63,24 @@ describe('if statements in SSR', () => {
 		const { body } = await render(App);
 		expect(body).toBe('<div>Default Case</div>');
 	});
-});
+
+	it('renders nested if-else blocks correctly', async () => {
+		component App() {
+			let outer = true;
+			let inner = false;
+
+			if (outer) {
+				if (inner) {
+					<div>{'Outer true, Inner true'}</div>
+				} else {
+					<div>{'Outer true, Inner false'}</div>
+				}
+			} else {
+				<div>{'Outer false'}</div>
+			}
+		}
+
+		const { body } = await render(App);
+		expect(body).toBe('<div>Outer true, Inner false</div>');
+	});
+});

package/tests/utils/escaping.test.js

@@ -0,0 +1,102 @@
+import { describe, it, expect } from 'vitest';
+import { escape } from '../../src/utils/escaping.js';
+
+describe('escape utility', () => {
+	describe('content escaping (is_attr = false)', () => {
+		it('should escape & to &', () => {
+			expect(escape('foo & bar', false)).toBe('foo & bar');
+		});
+
+		it('should escape < to &lt;', () => {
+			expect(escape('foo < bar', false)).toBe('foo &lt; bar');
+		});
+
+		it('should escape multiple special characters', () => {
+			expect(escape('a & b < c', false)).toBe('a &amp; b &lt; c');
+		});
+
+		it('should not escape double quotes in content', () => {
+			expect(escape('foo "bar" baz', false)).toBe('foo "bar" baz');
+		});
+
+		it('should handle empty string', () => {
+			expect(escape('', false)).toBe('');
+		});
+
+		it('should handle string with no special characters', () => {
+			expect(escape('hello world', false)).toBe('hello world');
+		});
+
+		it('should handle null values', () => {
+			expect(escape(null, false)).toBe('');
+		});
+
+		it('should handle undefined values', () => {
+			expect(escape(undefined, false)).toBe('');
+		});
+
+		it('should handle numbers', () => {
+			expect(escape(123, false)).toBe('123');
+		});
+
+		it('should escape consecutive special characters', () => {
+			expect(escape('&&<<', false)).toBe('&amp;&amp;&lt;&lt;');
+		});
+
+		it('should handle special characters at start', () => {
+			expect(escape('&hello', false)).toBe('&amp;hello');
+		});
+
+		it('should handle special characters at end', () => {
+			expect(escape('hello<', false)).toBe('hello&lt;');
+		});
+	});
+
+	describe('attribute escaping (is_attr = true)', () => {
+		it('should escape & to &amp;', () => {
+			expect(escape('foo & bar', true)).toBe('foo &amp; bar');
+		});
+
+		it('should escape < to &lt;', () => {
+			expect(escape('foo < bar', true)).toBe('foo &lt; bar');
+		});
+
+		it('should escape " to &quot;', () => {
+			expect(escape('foo "bar" baz', true)).toBe('foo &quot;bar&quot; baz');
+		});
+
+		it('should escape all three special characters', () => {
+			expect(escape('a & b < c "d"', true)).toBe('a &amp; b &lt; c &quot;d&quot;');
+		});
+
+		it('should handle empty string', () => {
+			expect(escape('', true)).toBe('');
+		});
+
+		it('should handle string with no special characters', () => {
+			expect(escape('hello world', true)).toBe('hello world');
+		});
+
+		it('should handle null values', () => {
+			expect(escape(null, true)).toBe('');
+		});
+
+		it('should handle undefined values', () => {
+			expect(escape(undefined, true)).toBe('');
+		});
+
+		it('should escape consecutive quotes', () => {
+			expect(escape('"""', true)).toBe('&quot;&quot;&quot;');
+		});
+
+		it('should handle mixed escaping', () => {
+			expect(escape('<div class="foo & bar">', true)).toBe('&lt;div class=&quot;foo &amp; bar&quot;>');
+		});
+	});
+
+	describe('default parameter behavior', () => {
+		it('should default to content escaping when is_attr is undefined', () => {
+			expect(escape('foo "bar"')).toBe('foo "bar"');
+		});
+	});
+});

package/tests/utils/events.test.js

@@ -0,0 +1,147 @@
+import { describe, it, expect } from 'vitest';
+import {
+	is_delegated,
+	is_event_attribute,
+	is_capture_event,
+	get_attribute_event_name,
+	is_passive_event
+} from '../../src/utils/events.js';
+
+describe('events utility', () => {
+	describe('is_delegated', () => {
+		it('should return true for delegated events', () => {
+			expect(is_delegated('click')).toBe(true);
+			expect(is_delegated('input')).toBe(true);
+			expect(is_delegated('change')).toBe(true);
+			expect(is_delegated('mousedown')).toBe(true);
+			expect(is_delegated('keydown')).toBe(true);
+			expect(is_delegated('pointerdown')).toBe(true);
+			expect(is_delegated('touchstart')).toBe(true);
+			expect(is_delegated('focusin')).toBe(true);
+			expect(is_delegated('focusout')).toBe(true);
+		});
+
+		it('should return false for non-delegated events', () => {
+			expect(is_delegated('focus')).toBe(false);
+			expect(is_delegated('blur')).toBe(false);
+			expect(is_delegated('scroll')).toBe(false);
+			expect(is_delegated('load')).toBe(false);
+			expect(is_delegated('resize')).toBe(false);
+		});
+
+		it('should be case-sensitive', () => {
+			expect(is_delegated('Click')).toBe(false);
+			expect(is_delegated('CLICK')).toBe(false);
+		});
+	});
+
+	describe('is_event_attribute', () => {
+		it('should return true for valid event attributes', () => {
+			expect(is_event_attribute('onClick')).toBe(true);
+			expect(is_event_attribute('onInput')).toBe(true);
+			expect(is_event_attribute('onChange')).toBe(true);
+			expect(is_event_attribute('onMouseDown')).toBe(true);
+			expect(is_event_attribute('onKeyPress')).toBe(true);
+			expect(is_event_attribute('on-click')).toBe(true);
+			expect(is_event_attribute('on_click')).toBe(true);
+			expect(is_event_attribute('on$click')).toBe(true);
+			expect(is_event_attribute('on$')).toBe(true);
+			expect(is_event_attribute('on-')).toBe(true);
+			expect(is_event_attribute('on_')).toBe(true);
+			expect(is_event_attribute('on1')).toBe(true);
+			expect(is_event_attribute('on1click')).toBe(true);
+		});
+
+		it('should return false for non-event attributes', () => {
+			expect(is_event_attribute('on')).toBe(false);
+			expect(is_event_attribute('onclick')).toBe(false);
+			expect(is_event_attribute('class')).toBe(false);
+			expect(is_event_attribute('id')).toBe(false);
+			expect(is_event_attribute('value')).toBe(false);
+			expect(is_event_attribute('aria-label')).toBe(false);
+		});
+
+		it('should require uppercase third character', () => {
+			expect(is_event_attribute('onabc')).toBe(false);
+			expect(is_event_attribute('onAbc')).toBe(true);
+		});
+
+		it('should require at least 3 characters', () => {
+			expect(is_event_attribute('onA')).toBe(true);
+			expect(is_event_attribute('on')).toBe(false);
+			expect(is_event_attribute('o')).toBe(false);
+			expect(is_event_attribute('')).toBe(false);
+		});
+	});
+
+	describe('is_capture_event', () => {
+		it('should return true for capture events', () => {
+			expect(is_capture_event('clickCapture')).toBe(true);
+			expect(is_capture_event('mousedownCapture')).toBe(true);
+			expect(is_capture_event('keydownCapture')).toBe(true);
+		});
+
+		it('should return false for non-capture events', () => {
+			expect(is_capture_event('click')).toBe(false);
+			expect(is_capture_event('mousedown')).toBe(false);
+			expect(is_capture_event('mousedown')).toBe(false);
+		});
+
+		it('should exclude gotpointercapture and lostpointercapture', () => {
+			expect(is_capture_event('gotpointercapture')).toBe(false);
+			expect(is_capture_event('lostpointercapture')).toBe(false);
+			expect(is_capture_event('gotPointerCapture')).toBe(false);
+			expect(is_capture_event('lostPointerCapture')).toBe(false);
+		});
+
+		it('should be case-insensitive for pointer capture events', () => {
+			expect(is_capture_event('GOTPOINTERCAPTURE')).toBe(false);
+			expect(is_capture_event('LOSTPOINTERCAPTURE')).toBe(false);
+		});
+
+		it('should be case-sensitive for other events', () => {
+			expect(is_capture_event('clickCapture')).toBe(true);
+			expect(is_capture_event('keypressCapture')).toBe(true);
+			expect(is_capture_event('clickcapture')).toBe(false);
+			expect(is_capture_event('keypresscapture')).toBe(false);
+		})
+	});
+
+	describe('get_attribute_event_name', () => {
+		it('should convert event attribute names to lowercase and strip "on" prefix', () => {
+			expect(get_attribute_event_name('onClick')).toBe('click');
+			expect(get_attribute_event_name('onInput')).toBe('input');
+			expect(get_attribute_event_name('onMouseDown')).toBe('mousedown');
+			expect(get_attribute_event_name('onKeyPress')).toBe('keypress');
+			expect(get_attribute_event_name('onChange')).toBe('change');
+			expect(get_attribute_event_name('onFocus')).toBe('focus');
+		});
+
+		it('should handle capture events and strip both "on" and "Capture"', () => {
+			expect(get_attribute_event_name('onClickCapture')).toBe('click');
+			expect(get_attribute_event_name('onMouseDownCapture')).toBe('mousedown');
+			expect(get_attribute_event_name('onMouseDownCapture')).toBe('mousedown');
+			expect(get_attribute_event_name('onGotPointerCapture')).toBe('gotpointercapture');
+			expect(get_attribute_event_name('onLostPointerCapture')).toBe('lostpointercapture');
+		});
+	});
+
+	describe('is_passive_event', () => {
+		it('should return true for passive events', () => {
+			expect(is_passive_event('touchstart')).toBe(true);
+			expect(is_passive_event('touchmove')).toBe(true);
+		});
+
+		it('should return false for non-passive events', () => {
+			expect(is_passive_event('click')).toBe(false);
+			expect(is_passive_event('mousedown')).toBe(false);
+			expect(is_passive_event('touchend')).toBe(false);
+			expect(is_passive_event('scroll')).toBe(false);
+		});
+
+		it('should be case-sensitive', () => {
+			expect(is_passive_event('TouchStart')).toBe(false);
+			expect(is_passive_event('TOUCHMOVE')).toBe(false);
+		});
+	});
+});

package/tests/utils/normalize_css_property_name.test.js

@@ -0,0 +1,43 @@
+import { describe, it, expect } from 'vitest';
+import { normalize_css_property_name } from '../../src/utils/normalize_css_property_name.js';
+
+describe('normalize_css_property_name utility', () => {
+	it('should convert camelCase to kebab-case', () => {
+		expect(normalize_css_property_name('backgroundColor')).toBe('background-color');
+		expect(normalize_css_property_name('fontSize')).toBe('font-size');
+		expect(normalize_css_property_name('marginTop')).toBe('margin-top');
+		expect(normalize_css_property_name('borderRadius')).toBe('border-radius');
+	});
+
+	it('should handle multiple uppercase letters', () => {
+		expect(normalize_css_property_name('WebkitTransform')).toBe('-webkit-transform');
+		expect(normalize_css_property_name('MozAppearance')).toBe('-moz-appearance');
+	});
+
+	it('should preserve CSS custom properties (starting with --)', () => {
+		expect(normalize_css_property_name('--custom-property')).toBe('--custom-property');
+		expect(normalize_css_property_name('--myColor')).toBe('--myColor');
+		expect(normalize_css_property_name('--themePrimary')).toBe('--themePrimary');
+	});
+
+	it('should handle already lowercase properties', () => {
+		expect(normalize_css_property_name('color')).toBe('color');
+		expect(normalize_css_property_name('display')).toBe('display');
+		expect(normalize_css_property_name('position')).toBe('position');
+		expect(normalize_css_property_name('z-index')).toBe('z-index');
+	});
+
+	it('should handle consecutive uppercase letters', () => {
+		expect(normalize_css_property_name('HTMLElement')).toBe('-h-t-m-l-element');
+	});
+
+	it('should handle empty string', () => {
+		expect(normalize_css_property_name('')).toBe('');
+	});
+
+	it('should handle complex property names', () => {
+		expect(normalize_css_property_name('borderTopLeftRadius')).toBe('border-top-left-radius');
+		expect(normalize_css_property_name('textDecorationColor')).toBe('text-decoration-color');
+	});
+});
+