ripple 0.2.86 → 0.2.87

package/src/runtime/internal/client/operations.js

@@ -8,6 +8,7 @@ var next_sibling_getter;
 /** @type {Document} */
 export var document;
 
+/** @type {boolean} */
 export var is_firefox;
 
 export function init_operations() {
@@ -44,13 +45,17 @@ export function init_operations() {
  * @param {N} node
  * @returns {Node | null}
  */
-/*@__NO_SIDE_EFFECTS__*/
 export function first_child(node) {
 	return first_child_getter.call(node);
 }
 
+/**
+ * @template {Node} N
+ * @param {N} node
+ * @returns {Node | null}
+ */
 export function child_frag(node) {
-	var child = first_child(node);
+	var child = /** @type {Text} */ (first_child(node));
 
 	if (child.nodeType === 8 && child.data === '') {
 		return next_sibling(child);

package/src/runtime/internal/client/portal.js

@@ -1,12 +1,23 @@
+/** @import { Block } from '#client' */
+
 import { branch, destroy_block, render } from './blocks.js';
 import { UNINITIALIZED } from './constants.js';
 import { handle_root_events } from './events.js';
 import { create_text } from './operations.js';
 
+/**
+ * @param {any} _ 
+ * @param {{ target: Element, children: (anchor: Node) => void }} props
+ * @returns {void}
+ */
 export function Portal(_, props) {
+  /** @type {Element | symbol} */
   let target = UNINITIALIZED;
+  /** @type {((anchor: Node) => void) | symbol} */
   let children = UNINITIALIZED;
+  /** @type {Block | null} */
   var b = null;
+  /** @type {Text | null} */
   var anchor = null;
 
   render(() => {
@@ -18,15 +29,15 @@ export function Portal(_, props) {
     }
 
     anchor = create_text();
-    target.append(anchor);
+    /** @type {Element} */ (target).append(anchor);
 
-    const cleanup_events = handle_root_events(target);
+    const cleanup_events = handle_root_events(/** @type {Element} */ (target));
 
-    b = branch(() => children(anchor));
+    b = branch(() => /** @type {(anchor: Node) => void} */ (children)(/** @type {Text} */ (anchor)));
 
     return () => {
       cleanup_events();
-      anchor.remove();
+      /** @type {Text} */ (anchor).remove();
     };
   });
 }

package/src/runtime/internal/client/render.js

@@ -1,3 +1,5 @@
+/** @import { Block } from '#client' */
+
 import { destroy_block, ref } from './blocks.js';
 import { REF_PROP } from './constants.js';
 import {
@@ -14,6 +16,11 @@ import {
 } from '../../../utils/events.js';
 import { get } from './runtime.js';
 
+/**
+ * @param {Text} text
+ * @param {any} value
+ * @returns {void}
+ */
 export function set_text(text, value) {
   // For objects, we apply string coercion
   var str = value == null ? '' : typeof value === 'object' ? value + '' : value;
@@ -25,8 +32,13 @@ export function set_text(text, value) {
   }
 }
 
+/** @type {Map<string, string[]>} */
 var setters_cache = new Map();
 
+/**
+ * @param {Element} element
+ * @returns {string[]}
+ */
 function get_setters(element) {
   var setters = setters_cache.get(element.nodeName);
   if (setters) return setters;
@@ -53,6 +65,12 @@ function get_setters(element) {
   return setters;
 }
 
+/**
+ * @param {Element} element
+ * @param {string} attribute
+ * @param {any} value
+ * @returns {void}
+ */
 export function set_attribute(element, attribute, value) {
   // @ts-expect-error
   var attributes = (element.__attributes ??= {});
@@ -67,12 +85,17 @@ export function set_attribute(element, attribute, value) {
   if (value == null) {
     element.removeAttribute(attribute);
   } else if (typeof value !== 'string' && get_setters(element).includes(attribute)) {
-    element[attribute] = value;
+    /** @type {any} */ (element)[attribute] = value;
   } else {
     element.setAttribute(attribute, value);
   }
 }
 
+/**
+ * @param {Element} element
+ * @param {Record<string, any>} attributes
+ * @returns {void}
+ */
 export function set_attributes(element, attributes) {
   for (const key in attributes) {
     if (key === 'children') continue;
@@ -85,7 +108,7 @@ export function set_attributes(element, attributes) {
 
     if (key === 'class') {
       const is_html = element.namespaceURI === 'http://www.w3.org/1999/xhtml';
-      set_class(element, value, undefined, is_html);
+      set_class(/** @type {HTMLElement} */ (element), value, undefined, is_html);
     } else if (key === '#class') {
       // Special case for static class when spreading props
       element.classList.add(value);
@@ -95,7 +118,7 @@ export function set_attributes(element, attributes) {
 
       if (is_delegated(event_name)) {
         // Use delegation for delegated events
-        element['__' + event_name] = value;
+        /** @type {any} */ (element)['__' + event_name] = value;
         delegate([event_name]);
       } else {
         // Use addEventListener for non-delegated events
@@ -148,6 +171,11 @@ export function set_class(dom, value, hash, is_html = true) {
   }
 }
 
+/**
+ * @param {HTMLInputElement | HTMLProgressElement} element
+ * @param {any} value
+ * @returns {void}
+ */
 export function set_value(element, value) {
   // @ts-expect-error
   var attributes = (element.__attributes ??= {});
@@ -157,17 +185,20 @@ export function set_value(element, value) {
       (attributes.value =
         // treat null and undefined the same for the initial value
         value ?? undefined) ||
-    // @ts-expect-error
     // `progress` elements always need their value set when it's `0`
     (element.value === value && (value !== 0 || element.nodeName !== 'PROGRESS'))
   ) {
     return;
   }
 
-  // @ts-expect-error
   element.value = value ?? '';
 }
 
+/**
+ * @param {HTMLInputElement} element
+ * @param {boolean} checked
+ * @returns {void}
+ */
 export function set_checked(element, checked) {
   // @ts-expect-error
   var attributes = (element.__attributes ??= {});
@@ -181,10 +212,14 @@ export function set_checked(element, checked) {
     return;
   }
 
-  // @ts-expect-error
   element.checked = checked;
 }
 
+/**
+ * @param {HTMLOptionElement} element
+ * @param {boolean} selected
+ * @returns {void}
+ */
 export function set_selected(element, selected) {
   if (selected) {
     // The selected option could've changed via user selection, and
@@ -197,8 +232,15 @@ export function set_selected(element, selected) {
   }
 }
 
+/**
+ * @param {Element} element
+ * @param {() => Record<string | symbol, any>} fn
+ * @returns {() => void}
+ */
 export function apply_element_spread(element, fn) {
+  /** @type {Record<string | symbol, any> | undefined} */
   var prev;
+  /** @type {Record<symbol, Block>} */
   var effects = {};
 
   return () => {

package/src/runtime/internal/client/runtime.js

@@ -26,7 +26,14 @@ import {
 	REF_PROP,
 } from './constants.js';
 import { capture, suspend } from './try.js';
-import { define_property, get_descriptors, is_array, is_tracked_object } from './utils.js';
+import {
+	define_property,
+	get_descriptors,
+	get_own_property_symbols,
+	is_array,
+	is_tracked_object,
+  object_keys,
+} from './utils.js';
 
 const FLUSH_MICROTASK = 0;
 const FLUSH_SYNC = 1;
@@ -40,17 +47,22 @@ export let active_scope = null;
 /** @type {null | Component} */
 export let active_component = null;
 
+/** @type {Map<Tracked, any>} */
 var old_values = new Map();
 
 // Used for controlling the flush of blocks
+/** @type {number} */
 let scheduler_mode = FLUSH_MICROTASK;
 // Used for handling scheduling
+/** @type {boolean} */
 let is_micro_task_queued = false;
+/** @type {number} */
 let clock = 0;
 /** @type {Block[]} */
 let queued_root_blocks = [];
 /** @type {(() => void)[]} */
 let queued_microtasks = [];
+/** @type {number} */
 let flush_count = 0;
 /** @type {null | Dependency} */
 let active_dependency = null;
@@ -58,6 +70,9 @@ let active_dependency = null;
 export let tracking = false;
 export let teardown = false;
 
+/**
+ * @returns {number}
+ */
 function increment_clock() {
 	return ++clock;
 }
@@ -421,16 +436,25 @@ export function is_block_dirty(block) {
 	return is_tracking_dirty(block.d);
 }
 
+/**
+ * @param {() => Promise<any>} fn
+ * @param {Block} block
+ * @returns {Promise<Tracked>}
+ */
 export function async_computed(fn, block) {
+	/** @type {Block | Derived | null} */
 	let parent = active_reaction;
 	var t = tracked(UNINITIALIZED, block);
+	/** @type {Promise<any>} */
 	var promise;
+	/** @type {Map<Tracked, {v: any, c: number}>} */
 	var new_values = new Map();
 
 	render(() => {
 		var [current, deferred] = capture_deferred(() => (promise = fn()));
 
 		var restore = capture();
+		/** @type {(() => void) | undefined} */
 		var unuspend;
 
 		if (deferred === null) {
@@ -443,7 +467,7 @@ export function async_computed(fn, block) {
 		}
 
 		promise.then((v) => {
-			if (is_destroyed(parent)) {
+			if (parent && is_destroyed(/** @type {Block} */ (parent))) {
 				return;
 			}
 			if (promise === current && t.v !== v) {
@@ -457,11 +481,12 @@ export function async_computed(fn, block) {
 			}
 
 			if (deferred === null) {
-				unuspend();
+				unuspend?.();
 			} else if (promise === current) {
 				for (var i = 0; i < deferred.length; i++) {
 					var tracked = deferred[i];
-					var { v, c } = new_values.get(tracked);
+					var stored = /** @type {{ v: any, c: number }} */ (new_values.get(tracked));
+					var { v, c } = stored;
 					tracked.v = v;
 					tracked.c = c;
 					schedule_update(tracked.b);
@@ -478,48 +503,13 @@ export function async_computed(fn, block) {
 	});
 }
 
-export function deferred(fn) {
-	// var parent = active_block;
-	// var block = active_scope;
-	// var res = [UNINITIALIZED];
-	// // TODO implement DEFERRED flag on tracked
-	// var t = tracked(UNINITIALIZED, block, DEFERRED);
-	// var tracked_properties = [t];
-	// var prev_value = UNINITIALIZED;
-	// define_property(res, TRACKED_OBJECT, {
-	//   value: tracked_properties,
-	//   enumerable: false,
-	// });
-	// render(() => {
-	//   if (prev_value !== UNINITIALIZED) {
-	//     t.v = prev_value;
-	//   } else {
-	//     prev_value = t.v;
-	//   }
-	//   var prev_version = t.c;
-	//   var value = fn();
-	//   res[0] = value;
-	//   old_set_property(res, 0, value, block);
-	//   if (prev_value !== UNINITIALIZED) {
-	//     if ((t.f & DEFERRED) === 0) {
-	//       t.f ^= DEFERRED;
-	//     }
-	//     var is_awaited = flush_deferred_upodates(parent);
-	//     if ((t.f & DEFERRED) !== 0) {
-	//       t.f ^= DEFERRED;
-	//     }
-	//     if (is_awaited) {
-	//       t.c = prev_version;
-	//       t.v = prev_value;
-	//       prev_value = value;
-	//     }
-	//   }
-	// });
-	// return res;
-}
-
+/**
+ * @param {() => any} fn
+ * @returns {[any, Tracked[] | null]}
+ */
 function capture_deferred(fn) {
 	var value = fn();
+	/** @type {Tracked[] | null} */
 	var deferred = null;
 	var depedency = active_dependency;
 
@@ -536,36 +526,6 @@ function capture_deferred(fn) {
 	return [value, deferred];
 }
 
-/**
- * @param {Block} block
- */
-function flush_deferred_upodates(block) {
-	var current = block.first;
-	var is_awaited = false;
-
-	main_loop: while (current !== null) {
-		var flags = current.f;
-
-		if ((flags & ASYNC_BLOCK) !== 0 && is_block_dirty(current)) {
-			is_awaited = true;
-			run_block(current);
-		}
-
-		var parent = current.p;
-		current = current.next;
-
-		while (current === null && parent !== null) {
-			if (parent === block) {
-				break main_loop;
-			}
-			current = parent.next;
-			parent = parent.p;
-		}
-	}
-
-	return is_awaited;
-}
-
 /**
  * @param {Block} root_block
  */
@@ -642,6 +602,9 @@ function flush_queued_root_blocks(root_blocks) {
 	}
 }
 
+/**
+ * @returns {void}
+ */
 function flush_microtasks() {
 	is_micro_task_queued = false;
 
@@ -875,6 +838,14 @@ export function spread_props(fn, block) {
 				const obj = get_derived(computed);
 				return obj[property];
 			},
+      has(target, property) {
+        const obj = get_derived(computed);
+        return property in obj;
+      },
+			ownKeys() {
+				const obj = get_derived(computed);
+				return Reflect.ownKeys(obj);
+			},
 		},
 	);
 }
@@ -931,6 +902,13 @@ export function get_property(obj, property, chain = false) {
 	return get(tracked);
 }
 
+/**
+ * @param {any} obj
+ * @param {string | number | symbol} property
+ * @param {any} value
+ * @param {Block} block
+ * @returns {void}
+ */
 export function set_property(obj, property, value, block) {
 	var tracked = obj[property];
 	set(tracked, value, block);
@@ -980,6 +958,13 @@ export function update_pre(tracked, block, d = 1) {
 	return new_value;
 }
 
+/**
+ * @param {any} obj
+ * @param {string | number | symbol} property
+ * @param {Block} block
+ * @param {number} [d=1]
+ * @returns {number}
+ */
 export function update_property(obj, property, block, d = 1) {
 	var tracked = obj[property];
 	var value = get(tracked);
@@ -988,6 +973,13 @@ export function update_property(obj, property, block, d = 1) {
 	return new_value;
 }
 
+/**
+ * @param {any} obj
+ * @param {string | number | symbol} property
+ * @param {Block} block
+ * @param {number} [d=1]
+ * @returns {number}
+ */
 export function update_pre_property(obj, property, block, d = 1) {
 	var tracked = obj[property];
 	var value = get(tracked);
@@ -1031,6 +1023,9 @@ export function safe_scope(err = 'Cannot access outside of a component context')
 	return /** @type {Block} */ (active_scope);
 }
 
+/**
+ * @returns {void}
+ */
 export function push_component() {
 	var component = {
 		c: null,
@@ -1041,6 +1036,9 @@ export function push_component() {
 	active_component = component;
 }
 
+/**
+ * @returns {void}
+ */
 export function pop_component() {
 	var component = /** @type {Component} */ (active_component);
 	component.m = true;
@@ -1065,6 +1063,9 @@ export function pop_component() {
 	active_component = component.p;
 }
 
+/**
+ * @returns {symbol}
+ */
 export function ref_prop() {
 	return Symbol(REF_PROP);
 }
@@ -1080,21 +1081,35 @@ export function fallback(value, fallback) {
 }
 
 /**
- * @param {Record<string, unknown>} obj
- * @param {string[]} keys
- * @returns {Record<string, unknown>}
+ * @param {Record<string | symbol, unknown>} obj
+ * @param {string[]} exclude_keys
+ * @returns {Record<string | symbol, unknown>}
  */
-export function exclude_from_object(obj, keys) {
-	obj = { ...obj };
-	let key;
-	for (key of keys) {
-		delete obj[key];
+export function exclude_from_object(obj, exclude_keys) {
+  var keys = object_keys(obj);
+	/** @type {Record<string | symbol, unknown>} */
+	var new_obj = {};
+  
+  for (const key of keys) {
+    if (!exclude_keys.includes(key)) {
+      new_obj[key] = obj[key];
+    }
+  }
+
+	for (const symbol of get_own_property_symbols(obj)) {
+		var ref_fn = obj[symbol];
+
+		if (symbol.description === REF_PROP) {
+			new_obj[symbol] = ref_fn;
+		}
 	}
-	return obj;
+
+	return new_obj;
 }
 
 /**
  * @param {any} v
+ * @returns {Promise<() => any>}
  */
 export async function maybe_tracked(v) {
 	var restore = capture();

package/src/runtime/internal/client/template.js

@@ -1,3 +1,5 @@
+/** @import { Block } from '#client' */
+
 import {
   TEMPLATE_FRAGMENT,
   TEMPLATE_USE_IMPORT_NODE,
@@ -49,13 +51,14 @@ function create_fragment_from_html(html, use_svg_namespace = false, use_mathml_n
  * Creates a template node or fragment from content and flags.
  * @param {string} content - The template content.
  * @param {number} flags - Flags for template type.
- * @returns {Node}
+ * @returns {() => Node}
  */
 export function template(content, flags) {
   var is_fragment = (flags & TEMPLATE_FRAGMENT) !== 0;
   var use_import_node = (flags & TEMPLATE_USE_IMPORT_NODE) !== 0;
   var use_svg_namespace = (flags & TEMPLATE_SVG_NAMESPACE) !== 0;
   var use_mathml_namespace = (flags & TEMPLATE_MATHML_NAMESPACE) !== 0;
+  /** @type {Node | DocumentFragment | undefined} */
   var node;
   var has_start = !content.startsWith('<!>');
 
@@ -66,17 +69,17 @@ export function template(content, flags) {
         use_svg_namespace,
         use_mathml_namespace,
       );
-      if (!is_fragment) node = first_child(node);
+      if (!is_fragment) node = /** @type {Node} */ (first_child(node));
     }
 
     var clone =
-      use_import_node || is_firefox ? document.importNode(node, true) : node.cloneNode(true);
+      use_import_node || is_firefox ? document.importNode(/** @type {Node} */ (node), true) : /** @type {Node} */ (node).cloneNode(true);
 
     if (is_fragment) {
       var start = first_child(clone);
       var end = clone.lastChild;
 
-      assign_nodes(start, end);
+      assign_nodes(/** @type {Node} */ (start), /** @type {Node} */ (end));
     } else {
       assign_nodes(clone, clone);
     }
@@ -87,7 +90,7 @@ export function template(content, flags) {
 
 /**
  * Appends a DOM node before the anchor node.
- * @param {Node} anchor - The anchor node.
+ * @param {ChildNode} anchor - The anchor node.
  * @param {Node} dom - The DOM node to append.
  */
 export function append(anchor, dom) {