ripple 0.1.1 → 0.2.0

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

@@ -0,0 +1,51 @@
+import { TEMPLATE_FRAGMENT, TEMPLATE_USE_IMPORT_NODE } from '../../../constants.js';
+import { first_child, is_firefox } from './operations.js';
+import { active_block } from './runtime.js';
+
+export function assign_nodes(start, end) {
+	var block = /** @type {Effect} */ (active_block);
+	if (block.s === null) {
+		block.s = {
+			start,
+			end
+		};
+	}
+}
+
+function create_fragment_from_html(html) {
+	var elem = document.createElement('template');
+	elem.innerHTML = html;
+	return elem.content;
+}
+
+export function template(content, flags) {
+	var is_fragment = (flags & TEMPLATE_FRAGMENT) !== 0;
+	var use_import_node = (flags & TEMPLATE_USE_IMPORT_NODE) !== 0;
+	var node;
+	var has_start = !content.startsWith('<!>');
+
+	return () => {
+		if (node === undefined) {
+			node = create_fragment_from_html(has_start ? content : '<!>' + content);
+			if (!is_fragment) node = first_child(node);
+		}
+
+		var clone =
+			use_import_node || is_firefox ? document.importNode(node, true) : node.cloneNode(true);
+
+		if (is_fragment) {
+			var start = first_child(clone);
+			var end = clone.lastChild;
+
+			assign_nodes(start, end);
+		} else {
+			assign_nodes(clone, clone);
+		}
+
+		return clone;
+	};
+}
+
+export function append(anchor, dom) {
+	anchor.before(/** @type {Node} */ (dom));
+}

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

@@ -0,0 +1,139 @@
+import { branch, create_try_block, destroy_block, is_destroyed, resume_block } from './blocks';
+import { TRY_BLOCK } from './constants';
+import { next_sibling } from './operations';
+import {
+	active_block,
+	active_component,
+	active_reaction,
+	queue_microtask,
+	set_active_block,
+	set_active_component,
+	set_active_reaction,
+	set_tracking,
+	tracking
+} from './runtime';
+
+export function try_block(node, fn, catch_fn, pending_fn = null) {
+	var anchor = node;
+	var b = null;
+	var suspended = null;
+	var pending_count = 0;
+	var offscreen_fragment = null;
+
+	function move_block(block, fragment) {
+		var state = block.s;
+		var node = state.start;
+		var end = state.end;
+
+		while (node !== null) {
+			var next = node === end ? null : next_sibling(node);
+
+			fragment.append(node);
+			node = next;
+		}
+	}
+
+	function handle_await() {
+		if (pending_count++ === 0) {
+			queue_microtask(() => {
+				if (b !== null) {
+					suspended = b;
+					offscreen_fragment = document.createDocumentFragment();
+					move_block(b, offscreen_fragment);
+
+					b = branch(() => {
+						pending_fn(anchor);
+					});
+				}
+			});
+		}
+
+		return () => {
+			if (--pending_count === 0) {
+				if (b !== null) {
+					destroy_block(b);
+				}
+				anchor.before(offscreen_fragment);
+				offscreen_fragment = null;
+				resume_block(suspended);
+				b = suspended;
+				suspended = null;
+			}
+		};
+	}
+
+	function handle_error(error) {
+		if (b !== null) {
+			destroy_block(b);
+		}
+
+		b = branch(() => {
+			catch_fn(anchor, error);
+		});
+	}
+
+	var state = {
+		a: pending_fn !== null ? handle_await : null,
+		c: catch_fn !== null ? handle_error : null
+	};
+
+	create_try_block(() => {
+		b = branch(() => {
+			fn(anchor);
+		});
+	}, state);
+}
+
+export function suspend() {
+	var current = active_block;
+
+	while (current !== null) {
+		var state = current.s;
+		if ((current.f & TRY_BLOCK) !== 0 && state.a !== null) {
+			return state.a();
+		}
+		current = current.p;
+	}
+
+	throw new Error('Missing parent `try { ... } async { ... }` statement');
+}
+
+function exit() {
+	set_tracking(false);
+	set_active_reaction(null);
+	set_active_block(null);
+	set_active_component(null);
+}
+
+export function capture() {
+	var previous_tracking = tracking;
+	var previous_block = active_block;
+	var previous_reaction = active_reaction;
+    var previous_component = active_component;
+
+	return () => {
+		set_tracking(previous_tracking);
+		set_active_block(previous_block);
+		set_active_reaction(previous_reaction);
+        set_active_component(previous_component);
+
+		queue_microtask(exit);
+	};
+}
+
+export function aborted() {
+	if (active_block === null) {
+		return true;
+	}
+	return is_destroyed(active_block);
+}
+
+export async function resume_context(promise) {
+	var restore = capture();
+	var value = await promise;
+
+	return () => {
+		restore();
+		return value;
+	};
+}

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

@@ -0,0 +1,16 @@
+export var get_descriptor = Object.getOwnPropertyDescriptor;
+export var get_descriptors = Object.getOwnPropertyDescriptors;
+export var array_from = Array.from;
+export var is_array = Array.isArray;
+export var define_property = Object.defineProperty;
+export var get_prototype_of = Object.getPrototypeOf;
+export var object_values = Object.values;
+export var object_entries = Object.entries;
+export var object_keys = Object.keys;
+export var structured_clone = structuredClone;
+
+export function create_anchor() {
+	var t = document.createTextNode('');
+	t.__t = '';
+	return t;
+}

package/src/utils/ast.js

@@ -0,0 +1,214 @@
+import * as b from './builders.js';
+
+export function object(expression) {
+	while (expression.type === 'MemberExpression') {
+		expression = /** @type {ESTree.MemberExpression | ESTree.Identifier} */ (expression.object);
+	}
+
+	if (expression.type !== 'Identifier') {
+		return null;
+	}
+
+	return expression;
+}
+
+export function unwrap_pattern(pattern, nodes = []) {
+	switch (pattern.type) {
+		case 'Identifier':
+			nodes.push(pattern);
+			break;
+
+		case 'MemberExpression':
+			// member expressions can be part of an assignment pattern, but not a binding pattern
+			// see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Destructuring_assignment#binding_and_assignment
+			nodes.push(pattern);
+			break;
+
+		case 'ObjectPattern':
+			for (const prop of pattern.properties) {
+				if (prop.type === 'RestElement') {
+					unwrap_pattern(prop.argument, nodes);
+				} else {
+					unwrap_pattern(prop.value, nodes);
+				}
+			}
+
+			break;
+
+		case 'ArrayPattern':
+			for (const element of pattern.elements) {
+				if (element) unwrap_pattern(element, nodes);
+			}
+
+			break;
+
+		case 'RestElement':
+			unwrap_pattern(pattern.argument, nodes);
+			break;
+
+		case 'AssignmentPattern':
+			unwrap_pattern(pattern.left, nodes);
+			break;
+	}
+
+	return nodes;
+}
+
+export function extract_identifiers(pattern) {
+	return unwrap_pattern(pattern, []).filter((node) => node.type === 'Identifier');
+}
+
+export function extract_paths(param) {
+	return _extract_paths(
+		[],
+		param,
+		(node) => /** @type {ESTree.Identifier | ESTree.MemberExpression} */ (node),
+		(node) => /** @type {ESTree.Identifier | ESTree.MemberExpression} */ (node),
+		false
+	);
+}
+
+function _extract_paths(assignments = [], param, expression, update_expression, has_default_value) {
+	switch (param.type) {
+		case 'Identifier':
+		case 'MemberExpression':
+			assignments.push({
+				node: param,
+				is_rest: false,
+				has_default_value,
+				expression,
+				update_expression
+			});
+			break;
+
+		case 'ObjectPattern':
+			for (const prop of param.properties) {
+				if (prop.type === 'RestElement') {
+					/** @type {DestructuredAssignment['expression']} */
+					const rest_expression = (object) => {
+						/** @type {ESTree.Expression[]} */
+						const props = [];
+
+						for (const p of param.properties) {
+							if (p.type === 'Property' && p.key.type !== 'PrivateIdentifier') {
+								if (p.key.type === 'Identifier' && !p.computed) {
+									props.push(b.literal(p.key.name));
+								} else if (p.key.type === 'Literal') {
+									props.push(b.literal(String(p.key.value)));
+								} else {
+									props.push(b.call('String', p.key));
+								}
+							}
+						}
+
+						return b.call('$.exclude_from_object', expression(object), b.array(props));
+					};
+
+					if (prop.argument.type === 'Identifier') {
+						assignments.push({
+							node: prop.argument,
+							is_rest: true,
+							has_default_value,
+							expression: rest_expression,
+							update_expression: rest_expression
+						});
+					} else {
+						_extract_paths(
+							assignments,
+							prop.argument,
+							rest_expression,
+							rest_expression,
+							has_default_value
+						);
+					}
+				} else {
+					/** @type {DestructuredAssignment['expression']} */
+					const object_expression = (object) =>
+						b.member(expression(object), prop.key, prop.computed || prop.key.type !== 'Identifier');
+					_extract_paths(
+						assignments,
+						prop.value,
+						object_expression,
+						object_expression,
+						has_default_value
+					);
+				}
+			}
+
+			break;
+
+		case 'ArrayPattern':
+			for (let i = 0; i < param.elements.length; i += 1) {
+				const element = param.elements[i];
+				if (element) {
+					if (element.type === 'RestElement') {
+						/** @type {DestructuredAssignment['expression']} */
+						const rest_expression = (object) =>
+							b.call(b.member(expression(object), 'slice'), b.literal(i));
+						if (element.argument.type === 'Identifier') {
+							assignments.push({
+								node: element.argument,
+								is_rest: true,
+								has_default_value,
+								expression: rest_expression,
+								update_expression: rest_expression
+							});
+						} else {
+							_extract_paths(
+								assignments,
+								element.argument,
+								rest_expression,
+								rest_expression,
+								has_default_value
+							);
+						}
+					} else {
+						/** @type {DestructuredAssignment['expression']} */
+						const array_expression = (object) => b.member(expression(object), b.literal(i), true);
+						_extract_paths(
+							assignments,
+							element,
+							array_expression,
+							array_expression,
+							has_default_value
+						);
+					}
+				}
+			}
+
+			break;
+
+		case 'AssignmentPattern': {
+			/** @type {DestructuredAssignment['expression']} */
+			const fallback_expression = (object) => build_fallback(expression(object), param.right);
+
+			if (param.left.type === 'Identifier') {
+				assignments.push({
+					node: param.left,
+					is_rest: false,
+					has_default_value: true,
+					expression: fallback_expression,
+					update_expression
+				});
+			} else {
+				_extract_paths(assignments, param.left, fallback_expression, update_expression, true);
+			}
+
+			break;
+		}
+	}
+
+	return assignments;
+}
+
+/**
+ * @param {ESTree.AssignmentOperator} operator
+ * @param {ESTree.Identifier | ESTree.MemberExpression} left
+ * @param {ESTree.Expression} right
+ */
+export function build_assignment_value(operator, left, right) {
+	return operator === '='
+		? right
+		: // turn something like x += 1 into x = x + 1
+			b.binary(/** @type {ESTree.BinaryOperator} */ (operator.slice(0, -1)), left, right);
+}