ripple 0.2.113 → 0.2.115

package/tests/client/input-value.test.ripple

@@ -1,6 +1,6 @@
 import { describe, it, expect, beforeEach, afterEach } from 'vitest';
 import { mount, flushSync, track, effect } from 'ripple';
-import { value, checked } from 'ripple/bindings';
+import { bindValue, bindChecked } from 'ripple';
 
 describe('use value()', () => {
 	let container;
@@ -22,42 +22,102 @@ describe('use value()', () => {
 	});
 
 	it('should update value on input', () => {
+		const logs = [];
+
 		component App() {
 			const text = track('');
 
 			effect(() => {
-				console.log('text changed', @text);
+				logs.push('text changed', @text);
+			});
+
+			<input type="text" {ref bindValue(text)} />
+		}
+		render(App);
+		flushSync();
+
+		const input = container.querySelector('input');
+		input.value = 'Hello';
+		input.dispatchEvent(new Event('input'));
+		flushSync();
+		expect(input.value).toBe('Hello');
+		expect(logs).toEqual(['text changed', '', 'text changed', 'Hello']);
+	});
+
+		it('should update value on input with a predefined value', () => {
+		const logs = [];
+
+		component App() {
+			const text = track('foo');
+
+			effect(() => {
+				logs.push('text changed', @text);
 			});
 
-			<input type="text" {ref value(text)} />
+			<input type="text" {ref bindValue(text)} />
 		}
 		render(App);
 		flushSync();
 
+		expect(container.querySelector('input').value).toBe('foo');
 		const input = container.querySelector('input');
 		input.value = 'Hello';
 		input.dispatchEvent(new Event('input'));
 		flushSync();
 		expect(input.value).toBe('Hello');
+		expect(logs).toEqual(['text changed', 'foo', 'text changed', 'Hello']);
 	});
 
 	it('should update checked on input', () => {
+		const logs = [];
+
 		component App() {
 			const value = track(false);
 
 			effect(() => {
-				console.log('checked changed', @value);
+				logs.push('checked changed', @value);
 			});
 
-			<input type="checkbox" {ref checked(value)} />
+			<input type="checkbox" {ref bindChecked(value)} />
 		}
 		render(App);
 		flushSync();
 
 		const input = container.querySelector('input');
 		input.checked = true;
-		input.dispatchEvent(new Event('input'));
+		input.dispatchEvent(new Event('change'));
 		flushSync();
+		
 		expect(input.checked).toBe(true);
+		expect(logs).toEqual(['checked changed', false, 'checked changed', true]);
+	});
+
+	it('should update select value on change', () => {
+		const logs = [];
+
+		component App() {
+			const select = track('2');
+
+			effect(() => {
+				logs.push('select changed', @select);
+			});
+
+			<select {ref bindValue(select)}>
+				<option value="1">{"One"}</option>
+				<option value="2">{"Two"}</option>
+				<option value="3">{"Three"}</option>
+			</select>
+		}
+
+		render(App);
+		flushSync();
+
+		const select = container.querySelector('select');
+		select.value = '3';
+		select.dispatchEvent(new Event('change'));
+		flushSync();
+
+		expect(select.value).toBe('3');
+		expect(logs).toEqual(['select changed', '2', 'select changed', '3']);
 	});
 });

package/types/index.d.ts

@@ -73,7 +73,23 @@ declare global {
 
 export declare function createRefKey(): symbol;
 
-export type Tracked<V> = { '#v': V };
+// Base Tracked interface - all tracked values have a '#v' property containing the actual value
+export interface Tracked<V> {	'#v': V; }
+
+// Augment Tracked to be callable when V is a Component
+// This allows <@Something /> to work in JSX when Something is Tracked<Component>
+export interface Tracked<V> {
+	(props: V extends Component<infer P> ? P : never): V extends Component ? void : never;
+}
+
+// Helper type to infer component type from a function that returns a component
+// If T is a function returning a Component, extract the Component type itself, not the return type (void)
+export type InferComponent<T> =
+	T extends () => infer R
+		? R extends Component<any>
+			? R
+			: T
+		: T;
 
 export type Props<K extends PropertyKey = any, V = unknown> = Record<K, V>;
 export type PropsWithExtras<T extends object> = Props & T & Record<string, unknown>;
@@ -90,7 +106,10 @@ type RestKeys<T, K extends readonly (keyof T)[]> = Expand<Omit<T, K[number]>>;
 type SplitResult<T extends Props, K extends readonly (keyof T)[]> =
 	[...PickKeys<T, K>, Tracked<RestKeys<T, K>>];
 
-export declare function track<V>(value?: V | (() => V), get?: (v: V) => V, set?: (next: V, prev: V) => V): Tracked<V>;
+// Overload for function values - infers the return type of the function
+export declare function track<V>(value: () => V, get?: (v: InferComponent<V>) => InferComponent<V>, set?: (next: InferComponent<V>, prev: InferComponent<V>) => InferComponent<V>): Tracked<InferComponent<V>>;
+// Overload for non-function values
+export declare function track<V>(value?: V, get?: (v: V) => V, set?: (next: V, prev: V) => V): Tracked<V>;
 
 export declare function trackSplit<V extends Props, const K extends readonly (keyof V)[]>(
 	value: V,
@@ -200,3 +219,15 @@ export declare const MediaQuery: {
 };
 
 export function Portal<V = HTMLElement>({ target, children: Component }: { target: V, children?: Component }): void;
+
+/**
+ * @param {Tracked<V>} tracked
+ * @returns {(node: HTMLInputElement | HTMLSelectElement) => void}
+ */
+export declare function bindValue<V>(tracked: Tracked<V>): (node: HTMLInputElement | HTMLSelectElement) => void;
+
+/**
+ * @param {Tracked<V>} tracked
+ * @returns {(node: HTMLInputElement) => void}
+ */
+export declare function bindChecked<V>(tracked: Tracked<V>): (node: HTMLInputElement) => void;

package/src/bindings/index.d.ts

@@ -1,13 +0,0 @@
-import type { Tracked } from "ripple";
-
-/**
- * @param {Tracked<V>} tracked
- * @returns {(node: HTMLInputElement) => void}
- */
-export declare function value<V>(tracked: Tracked<V>): (node: HTMLInputElement) => void;
-
-/**
- * @param {Tracked<V>} tracked
- * @returns {(node: HTMLInputElement) => void}
- */
-export declare function checked<V>(tracked: Tracked<V>): (node: HTMLInputElement) => void;

package/src/bindings/index.js

@@ -1,79 +0,0 @@
-/** @import {Block, Tracked} from '#client' */
-
-import { active_block, get, set, tick } from '../runtime/internal/client';
-import { on } from '../runtime/internal/client/events';
-import { is_tracked_object } from '../runtime/internal/client/utils';
-
-/**
- * @param {string} value
- */
-function to_number(value) {
-	return value === '' ? null : +value;
-}
-
-/**
- * @param {HTMLInputElement} input
- */
-function is_numberlike_input(input) {
-	var type = input.type;
-	return type === 'number' || type === 'range';
-}
-
-/**
- * @param {unknown} maybe_tracked
- * @returns {(node: HTMLInputElement) => void}
- */
-export function value(maybe_tracked) {
-	if (!is_tracked_object(maybe_tracked)) {
-		throw new TypeError('value() argument is not a tracked object');
-	}
-
-	const block = /** @type {Block} */ (active_block);
-	const tracked = /** @type {Tracked} */ (maybe_tracked);
-
-	return (input) => {
-		const clear_event = on(input, 'input', async () => {
-			/** @type {any} */
-			var value = input.value;
-			value = is_numberlike_input(input) ? to_number(value) : value;
-			set(tracked, value, block);
-
-			await tick();
-
-			if (value !== (value = get(tracked))) {
-				var start = input.selectionStart;
-				var end = input.selectionEnd;
-				input.value = value ?? '';
-
-				// Restore selection
-				if (end !== null) {
-					input.selectionStart = start;
-					input.selectionEnd = Math.min(end, input.value.length);
-				}
-			}
-		});
-
-		return clear_event;
-	};
-}
-
-/**
- * @param {unknown} maybe_tracked
- * @returns {(node: HTMLInputElement) => void}
- */
-export function checked(maybe_tracked) {
-  if (!is_tracked_object(maybe_tracked)) {
-    throw new TypeError('checked() argument is not a tracked object');
-  }
-
-  const block = /** @type {any} */ (active_block);
-  const tracked = /** @type {Tracked<any>} */ (maybe_tracked);
-
-  return (input) => {
-    const clear_event = on(input, 'change', () => {
-      set(tracked, input.checked, block);
-    });
-
-    return clear_event;
-  };
-}