ripple 0.3.67 → 0.3.69

package/tests/server/composite.test.tsrx

@@ -2,213 +2,189 @@ import { RippleArray, RippleMap } from 'ripple';
 
 describe('generics', () => {
 	it('handles advanced generic ambiguity and edge cases', () => {
-		component App() {
-			// Ambiguous generics vs JSX / less-than parsing scenarios
-
-			// 7. Generic following optional chaining
-			const maybe = {
-				factory: function <T>() {
+		function App() {
+			return <>
+				const maybe = {
+					factory: function <T>() {
+						return {
+							make: function <U>() {
+								return 1;
+							},
+						};
+					},
+				};
+				const g = maybe?.factory<number>()?.make<boolean>();
+				// 8. Comparison operator (ensure '<' here NOT misparsed as generics)
+				let x = 10, y = 20;
+				const h =
+					x < y ? 'lt' : 'ge';
+				// 9. Chained comparisons with intervening generics
+				class Box<T> {
+					value: T;
+
+					constructor(value: T) {
+						this.value = value;
+					}
+
+					open<U>() {
+						return new Box<number>(1);
+					}
+				}
+				const limit = 100;
+				const i =
+					new Box<number>(2).value < limit ? 'ok' : 'no';
+				// 10. JSX / Element should still work
+				<div class="still-works">
+					<span>{'Test'}</span>
+				</div>
+				// 11. Generic function call vs Element: Identifier followed by generic args
+				function identity<T>(value: T): T {
+					return value;
+				}
+				const j = identity<number>(42);
+				// 12. Member + generic call immediately followed by another call
+				class Factory {
+					create<T>() {
+						return (value: T) => value;
+					}
+				}
+				const factory = new Factory();
+				const k = factory.create<number>()(123);
+				// 13. Multiple generic segments in chain
+				function foo<T>() {
+					return {
+						bar: function <U>() {
+							return {
+								baz: function <V>() {
+									return true;
+								},
+							};
+						},
+					};
+				}
+				const l = foo<number>().bar<string>().baz<boolean>();
+				// 14. Generic with constraint + default
+				type Extractor<T extends { id: number } = { id: number }> = (v: T) => number;
+				const m: Extractor<{ id: number }> = (v) => v.id;
+				// 15. Generic in angle after "new" + trailing call
+				class Wrapper<T> {
+					value: T;
+
+					constructor() {
+						this.value = null as unknown as T;
+					}
+
+					unwrap<U>() {
+						return null as unknown as U;
+					}
+				}
+				const n = new Wrapper<number>().unwrap<string>();
+				// 16. Angle brackets inside type assertion vs generic call
+				function getUnknown(): unknown {
+					return new Map<string, number>([['a', 1]]);
+				}
+				getUnknown.factory = function <T>() {
 					return {
 						make: function <U>() {
-							return 1;
+							return 2;
 						},
 					};
-				},
-			};
-			const g = maybe?.factory<number>()?.make<boolean>();
-
-			// 8. Comparison operator (ensure '<' here NOT misparsed as generics)
-			let x = 10, y = 20;
-			const h =
-				x < y ? 'lt' : 'ge';
-
-			// 9. Chained comparisons with intervening generics
-			class Box<T> {
-				value: T;
-
-				constructor(value: T) {
-					this.value = value;
+				};
+				const raw = getUnknown();
+				const o = (raw as Map<string, number>).get('a');
+				// 17. Generic with comma + trailing less-than comparison on next token
+				class Pair<T1, T2> {
+					first: T1;
+
+					second: T2;
+
+					constructor() {
+						this.first = null as unknown as T1;
+						this.second = null as unknown as T2;
+					}
 				}
-
-				open<U>() {
-					return new Box<number>(1);
+				const p = new Pair<number, string>();
+				const q =
+					1 < 2 ? p : null;
+				// 18. Nested generics with line breaks resembling JSX indentation
+				interface Node<T> {
+					value: T;
 				}
-			}
-			const limit = 100;
-			const i =
-				new Box<number>(2).value < limit ? 'ok' : 'no';
-
-			// 10. JSX / Element should still work
-			<div class="still-works">
-				<span>{'Test'}</span>
-			</div>
+				interface Edge<W> {
+					weight: W;
+				}
+				class Graph<N, E> {
+					nodes: N[];
 
-			// 11. Generic function call vs Element: Identifier followed by generic args
-			function identity<T>(value: T): T {
-				return value;
-			}
-			const j = identity<number>(42);
+					edges: E[];
 
-			// 12. Member + generic call immediately followed by another call
-			class Factory {
-				create<T>() {
+					constructor() {
+						this.nodes = [];
+						this.edges = [];
+					}
+				}
+				const r = new Graph<Node<string>, Edge<number>>();
+				// 19. Ternary containing generics in both branches
+				let flag = true;
+				const s = flag ? new Box<number>(1) : new Box<string>('string');
+				// 20. Generic inside template expression
+				const t = `length=${new RippleArray<number>().length}`;
+				// 21. Optional chaining + generic + property access
+				const registry = new RippleMap<string, number>();
+				const u = registry.get('id')?.toString();
+				// 22. Generic call used as callee for another call
+				function make<T>() {
 					return (value: T) => value;
 				}
-			}
-			const factory = new Factory();
-			const k = factory.create<number>()(123);
-
-			// 13. Multiple generic segments in chain
-			function foo<T>() {
-				return {
-					bar: function <U>() {
+				const v = make<number>()(10);
+				// 23. Generic followed by tagged template (ensure not confused with JSX)
+				function tagFn<T>(strings: TemplateStringsArray, ...values) {
+					return values[0];
+				}
+				const tagResult = tagFn`value`;
+				// 24. Sequence mixing: (a < b) + generic call in same statement
+				function compute<T>(x: T, y: T): T {
+					return y;
+				}
+				const w = x < y && compute<number>(x, y);
+				// Additional component focusing on edge crankers
+
+				// 28. Generic after parenthesized new expression
+				const aa = (new Box<number>(1)).open<string>();
+				// 29. Generic chain right after closing paren of IIFE
+				class Builder<Kind> {
+					finalize<Result>() {
 						return {
-							baz: function <V>() {
-								return true;
-							},
+							result: null as unknown as Result,
 						};
-					},
-				};
-			}
-			const l = foo<number>().bar<string>().baz<boolean>();
-
-			// 14. Generic with constraint + default
-			type Extractor<T extends { id: number } = { id: number }> = (v: T) => number;
-			const m: Extractor<{ id: number }> = (v) => v.id;
-
-			// 15. Generic in angle after "new" + trailing call
-			class Wrapper<T> {
-				value: T;
-
-				constructor() {
-					this.value = null as unknown as T;
+					}
 				}
-
-				unwrap<U>() {
-					return null as unknown as U;
+				const builder = new Builder<Number>();
+				const result = (function () {
+					return builder;
+				}() as Builder<Number>).finalize<boolean>();
+				// 30. Angle bracket start of conditional expression line
+				function adjust<T>(value: T): T {
+					return value;
 				}
-			}
-			const n = new Wrapper<number>().unwrap<string>();
-
-			// 16. Angle brackets inside type assertion vs generic call
-			function getUnknown(): unknown {
-				return new Map<string, number>([['a', 1]]);
-			}
-			getUnknown.factory = function <T>() {
-				return {
-					make: function <U>() {
-						return 2;
-					},
-				};
-			};
-			const raw = getUnknown();
-			const o = (raw as Map<string, number>).get('a');
-
-			// 17. Generic with comma + trailing less-than comparison on next token
-			class Pair<T1, T2> {
-				first: T1;
-
-				second: T2;
-
-				constructor() {
-					this.first = null as unknown as T1;
-					this.second = null as unknown as T2;
-				}
-			}
-			const p = new Pair<number, string>();
-			const q =
-				1 < 2 ? p : null;
-
-			// 18. Nested generics with line breaks resembling JSX indentation
-			interface Node<T> {
-				value: T;
-			}
-			interface Edge<W> {
-				weight: W;
-			}
-			class Graph<N, E> {
-				nodes: N[];
-
-				edges: E[];
-
-				constructor() {
-					this.nodes = [];
-					this.edges = [];
+				const val =
+					new Wrapper<number>().value < 100 ? adjust<number>(10) : adjust<number>(20);
+				// 32. Generic with comments inside angle list
+				class Mapper<Key, Value> {
+					map: Map<Key, Value>;
+
+					constructor() {
+						this.map = new Map<Key, Value>();
+					}
 				}
-			}
-			const r = new Graph<Node<string>, Edge<number>>();
-
-			// 19. Ternary containing generics in both branches
-			let flag = true;
-			const s = flag ? new Box<number>(1) : new Box<string>('string');
-
-			// 20. Generic inside template expression
-			const t = `length=${new RippleArray<number>().length}`;
-
-			// 21. Optional chaining + generic + property access
-			const registry = new RippleMap<string, number>();
-			const u = registry.get('id')?.toString();
-
-			// 22. Generic call used as callee for another call
-			function make<T>() {
-				return (value: T) => value;
-			}
-			const v = make<number>()(10);
-
-			// 23. Generic followed by tagged template (ensure not confused with JSX)
-			function tagFn<T>(strings: TemplateStringsArray, ...values) {
-				return values[0];
-			}
-			const tagResult = tagFn`value`;
-
-			// 24. Sequence mixing: (a < b) + generic call in same statement
-			function compute<T>(x: T, y: T): T {
-				return y;
-			}
-
-			const w = x < y && compute<number>(x, y);
-
-			// Additional component focusing on edge crankers
-
-			// 28. Generic after parenthesized new expression
-			const aa = (new Box<number>(1)).open<string>();
-
-			// 29. Generic chain right after closing paren of IIFE
-			class Builder<Kind> {
-				finalize<Result>() {
-					return {
-						result: null as unknown as Result,
-					};
-				}
-			}
-			const builder = new Builder<Number>();
-			const result = (function () {
-				return builder;
-			}() as Builder<Number>).finalize<boolean>();
-
-			// 30. Angle bracket start of conditional expression line
-			function adjust<T>(value: T): T {
-				return value;
-			}
-			const val =
-				new Wrapper<number>().value < 100 ? adjust<number>(10) : adjust<number>(20);
-
-			// 32. Generic with comments inside angle list
-			class Mapper<Key, Value> {
-				map: Map<Key, Value>;
-
-				constructor() {
-					this.map = new Map<Key, Value>();
-				}
-			}
-			const gg = new Mapper<
-				// key type
-				string /* value type */,
-				number
-			>();
-
-			// 33. Map of generic instance as key
-			const mm = new Map<RippleArray<number>, RippleArray<string>>();
+				const gg = new Mapper<
+					// key type
+					string /* value type */,
+					number
+				>();
+				// 33. Map of generic instance as key
+				const mm = new Map<RippleArray<number>, RippleArray<string>>();
+			</>;
 		}
 
 		render(App);

package/tests/server/context.test.tsrx

@@ -4,22 +4,28 @@ describe('Context API', () => {
 	it('handles context override in nested components', async () => {
 		const MessageContext = Context('default');
 
-		component Inner() {
-			const msg = MessageContext.get();
-			<span>{msg}</span>
+		function Inner() {
+			return <>
+				const msg = MessageContext.get();
+				<span>{msg}</span>
+			</>;
 		}
 
-		component Middle() {
-			MessageContext.set('middle');
-			<div>
-				<Inner />
-			</div>
+		function Middle() {
+			return <>
+				MessageContext.set('middle');
+				<div>
+					<Inner />
+				</div>
+			</>;
 		}
 
-		component Outer() {
-			MessageContext.set('outer');
-			<Middle />
-			<Inner />
+		function Outer() {
+			return <>
+				MessageContext.set('outer');
+				<Middle />
+				<Inner />
+			</>;
 		}
 
 		const { body } = await render(Outer);