lumen-plus 0.0.5 → 0.0.6

package/dist/utils/node_modules/svelte/src/internal/client/reactivity/effects.js

@@ -0,0 +1,717 @@
+/** @import { Blocker, ComponentContext, ComponentContextLegacy, Derived, Effect, TemplateNode, TransitionManager } from '#client' */
+import {
+	is_dirty,
+	active_effect,
+	active_reaction,
+	update_effect,
+	get,
+	is_destroying_effect,
+	remove_reactions,
+	set_active_reaction,
+	set_is_destroying_effect,
+	untrack,
+	untracking
+} from '../runtime.js';
+import {
+	DIRTY,
+	BRANCH_EFFECT,
+	RENDER_EFFECT,
+	EFFECT,
+	DESTROYED,
+	INERT,
+	EFFECT_RAN,
+	BLOCK_EFFECT,
+	ROOT_EFFECT,
+	EFFECT_TRANSPARENT,
+	DERIVED,
+	CLEAN,
+	EAGER_EFFECT,
+	HEAD_EFFECT,
+	MAYBE_DIRTY,
+	EFFECT_PRESERVED,
+	STALE_REACTION,
+	USER_EFFECT,
+	ASYNC,
+	CONNECTED,
+	MANAGED_EFFECT
+} from '#client/constants';
+import * as e from '../errors.js';
+import { DEV } from 'esm-env';
+import { define_property } from '../../shared/utils.js';
+import { get_next_sibling } from '../dom/operations.js';
+import { component_context, dev_current_component_function, dev_stack } from '../context.js';
+import { Batch, current_batch, schedule_effect } from './batch.js';
+import { flatten } from './async.js';
+import { without_reactive_context } from '../dom/elements/bindings/shared.js';
+import { set_signal_status } from './status.js';
+
+/**
+ * @param {'$effect' | '$effect.pre' | '$inspect'} rune
+ */
+export function validate_effect(rune) {
+	if (active_effect === null) {
+		if (active_reaction === null) {
+			e.effect_orphan(rune);
+		}
+
+		e.effect_in_unowned_derived();
+	}
+
+	if (is_destroying_effect) {
+		e.effect_in_teardown(rune);
+	}
+}
+
+/**
+ * @param {Effect} effect
+ * @param {Effect} parent_effect
+ */
+function push_effect(effect, parent_effect) {
+	var parent_last = parent_effect.last;
+	if (parent_last === null) {
+		parent_effect.last = parent_effect.first = effect;
+	} else {
+		parent_last.next = effect;
+		effect.prev = parent_last;
+		parent_effect.last = effect;
+	}
+}
+
+/**
+ * @param {number} type
+ * @param {null | (() => void | (() => void))} fn
+ * @param {boolean} sync
+ * @returns {Effect}
+ */
+function create_effect(type, fn, sync) {
+	var parent = active_effect;
+
+	if (DEV) {
+		// Ensure the parent is never an inspect effect
+		while (parent !== null && (parent.f & EAGER_EFFECT) !== 0) {
+			parent = parent.parent;
+		}
+	}
+
+	if (parent !== null && (parent.f & INERT) !== 0) {
+		type |= INERT;
+	}
+
+	/** @type {Effect} */
+	var effect = {
+		ctx: component_context,
+		deps: null,
+		nodes: null,
+		f: type | DIRTY | CONNECTED,
+		first: null,
+		fn,
+		last: null,
+		next: null,
+		parent,
+		b: parent && parent.b,
+		prev: null,
+		teardown: null,
+		wv: 0,
+		ac: null
+	};
+
+	if (DEV) {
+		effect.component_function = dev_current_component_function;
+	}
+
+	if (sync) {
+		try {
+			update_effect(effect);
+			effect.f |= EFFECT_RAN;
+		} catch (e) {
+			destroy_effect(effect);
+			throw e;
+		}
+	} else if (fn !== null) {
+		schedule_effect(effect);
+	}
+
+	/** @type {Effect | null} */
+	var e = effect;
+
+	// if an effect has already ran and doesn't need to be kept in the tree
+	// (because it won't re-run, has no DOM, and has no teardown etc)
+	// then we skip it and go to its child (if any)
+	if (
+		sync &&
+		e.deps === null &&
+		e.teardown === null &&
+		e.nodes === null &&
+		e.first === e.last && // either `null`, or a singular child
+		(e.f & EFFECT_PRESERVED) === 0
+	) {
+		e = e.first;
+		if ((type & BLOCK_EFFECT) !== 0 && (type & EFFECT_TRANSPARENT) !== 0 && e !== null) {
+			e.f |= EFFECT_TRANSPARENT;
+		}
+	}
+
+	if (e !== null) {
+		e.parent = parent;
+
+		if (parent !== null) {
+			push_effect(e, parent);
+		}
+
+		// if we're in a derived, add the effect there too
+		if (
+			active_reaction !== null &&
+			(active_reaction.f & DERIVED) !== 0 &&
+			(type & ROOT_EFFECT) === 0
+		) {
+			var derived = /** @type {Derived} */ (active_reaction);
+			(derived.effects ??= []).push(e);
+		}
+	}
+
+	return effect;
+}
+
+/**
+ * Internal representation of `$effect.tracking()`
+ * @returns {boolean}
+ */
+export function effect_tracking() {
+	return active_reaction !== null && !untracking;
+}
+
+/**
+ * @param {() => void} fn
+ */
+export function teardown(fn) {
+	const effect = create_effect(RENDER_EFFECT, null, false);
+	set_signal_status(effect, CLEAN);
+	effect.teardown = fn;
+	return effect;
+}
+
+/**
+ * Internal representation of `$effect(...)`
+ * @param {() => void | (() => void)} fn
+ */
+export function user_effect(fn) {
+	validate_effect('$effect');
+
+	if (DEV) {
+		define_property(fn, 'name', {
+			value: '$effect'
+		});
+	}
+
+	// Non-nested `$effect(...)` in a component should be deferred
+	// until the component is mounted
+	var flags = /** @type {Effect} */ (active_effect).f;
+	var defer = !active_reaction && (flags & BRANCH_EFFECT) !== 0 && (flags & EFFECT_RAN) === 0;
+
+	if (defer) {
+		// Top-level `$effect(...)` in an unmounted component — defer until mount
+		var context = /** @type {ComponentContext} */ (component_context);
+		(context.e ??= []).push(fn);
+	} else {
+		// Everything else — create immediately
+		return create_user_effect(fn);
+	}
+}
+
+/**
+ * @param {() => void | (() => void)} fn
+ */
+export function create_user_effect(fn) {
+	return create_effect(EFFECT | USER_EFFECT, fn, false);
+}
+
+/**
+ * Internal representation of `$effect.pre(...)`
+ * @param {() => void | (() => void)} fn
+ * @returns {Effect}
+ */
+export function user_pre_effect(fn) {
+	validate_effect('$effect.pre');
+	if (DEV) {
+		define_property(fn, 'name', {
+			value: '$effect.pre'
+		});
+	}
+	return create_effect(RENDER_EFFECT | USER_EFFECT, fn, true);
+}
+
+/** @param {() => void | (() => void)} fn */
+export function eager_effect(fn) {
+	return create_effect(EAGER_EFFECT, fn, true);
+}
+
+/**
+ * Internal representation of `$effect.root(...)`
+ * @param {() => void | (() => void)} fn
+ * @returns {() => void}
+ */
+export function effect_root(fn) {
+	Batch.ensure();
+	const effect = create_effect(ROOT_EFFECT | EFFECT_PRESERVED, fn, true);
+
+	return () => {
+		destroy_effect(effect);
+	};
+}
+
+/**
+ * An effect root whose children can transition out
+ * @param {() => void} fn
+ * @returns {(options?: { outro?: boolean }) => Promise<void>}
+ */
+export function component_root(fn) {
+	Batch.ensure();
+	const effect = create_effect(ROOT_EFFECT | EFFECT_PRESERVED, fn, true);
+
+	return (options = {}) => {
+		return new Promise((fulfil) => {
+			if (options.outro) {
+				pause_effect(effect, () => {
+					destroy_effect(effect);
+					fulfil(undefined);
+				});
+			} else {
+				destroy_effect(effect);
+				fulfil(undefined);
+			}
+		});
+	};
+}
+
+/**
+ * @param {() => void | (() => void)} fn
+ * @returns {Effect}
+ */
+export function effect(fn) {
+	return create_effect(EFFECT, fn, false);
+}
+
+/**
+ * Internal representation of `$: ..`
+ * @param {() => any} deps
+ * @param {() => void | (() => void)} fn
+ */
+export function legacy_pre_effect(deps, fn) {
+	var context = /** @type {ComponentContextLegacy} */ (component_context);
+
+	/** @type {{ effect: null | Effect, ran: boolean, deps: () => any }} */
+	var token = { effect: null, ran: false, deps };
+
+	context.l.$.push(token);
+
+	token.effect = render_effect(() => {
+		deps();
+
+		// If this legacy pre effect has already run before the end of the reset, then
+		// bail out to emulate the same behavior.
+		if (token.ran) return;
+
+		token.ran = true;
+		untrack(fn);
+	});
+}
+
+export function legacy_pre_effect_reset() {
+	var context = /** @type {ComponentContextLegacy} */ (component_context);
+
+	render_effect(() => {
+		// Run dirty `$:` statements
+		for (var token of context.l.$) {
+			token.deps();
+
+			var effect = token.effect;
+
+			// If the effect is CLEAN, then make it MAYBE_DIRTY. This ensures we traverse through
+			// the effects dependencies and correctly ensure each dependency is up-to-date.
+			if ((effect.f & CLEAN) !== 0 && effect.deps !== null) {
+				set_signal_status(effect, MAYBE_DIRTY);
+			}
+
+			if (is_dirty(effect)) {
+				update_effect(effect);
+			}
+
+			token.ran = false;
+		}
+	});
+}
+
+/**
+ * @param {() => void | (() => void)} fn
+ * @returns {Effect}
+ */
+export function async_effect(fn) {
+	return create_effect(ASYNC | EFFECT_PRESERVED, fn, true);
+}
+
+/**
+ * @param {() => void | (() => void)} fn
+ * @returns {Effect}
+ */
+export function render_effect(fn, flags = 0) {
+	return create_effect(RENDER_EFFECT | flags, fn, true);
+}
+
+/**
+ * @param {(...expressions: any) => void | (() => void)} fn
+ * @param {Array<() => any>} sync
+ * @param {Array<() => Promise<any>>} async
+ * @param {Blocker[]} blockers
+ */
+export function template_effect(fn, sync = [], async = [], blockers = []) {
+	flatten(blockers, sync, async, (values) => {
+		create_effect(RENDER_EFFECT, () => fn(...values.map(get)), true);
+	});
+}
+
+/**
+ * Like `template_effect`, but with an effect which is deferred until the batch commits
+ * @param {(...expressions: any) => void | (() => void)} fn
+ * @param {Array<() => any>} sync
+ * @param {Array<() => Promise<any>>} async
+ * @param {Blocker[]} blockers
+ */
+export function deferred_template_effect(fn, sync = [], async = [], blockers = []) {
+	var batch = /** @type {Batch} */ (current_batch);
+	var is_async = async.length > 0 || blockers.length > 0;
+
+	if (is_async) batch.increment(true);
+
+	flatten(blockers, sync, async, (values) => {
+		create_effect(EFFECT, () => fn(...values.map(get)), false);
+		if (is_async) batch.decrement(true);
+	});
+}
+
+/**
+ * @param {(() => void)} fn
+ * @param {number} flags
+ */
+export function block(fn, flags = 0) {
+	var effect = create_effect(BLOCK_EFFECT | flags, fn, true);
+	if (DEV) {
+		effect.dev_stack = dev_stack;
+	}
+	return effect;
+}
+
+/**
+ * @param {(() => void)} fn
+ * @param {number} flags
+ */
+export function managed(fn, flags = 0) {
+	var effect = create_effect(MANAGED_EFFECT | flags, fn, true);
+	if (DEV) {
+		effect.dev_stack = dev_stack;
+	}
+	return effect;
+}
+
+/**
+ * @param {(() => void)} fn
+ */
+export function branch(fn) {
+	return create_effect(BRANCH_EFFECT | EFFECT_PRESERVED, fn, true);
+}
+
+/**
+ * @param {Effect} effect
+ */
+export function execute_effect_teardown(effect) {
+	var teardown = effect.teardown;
+	if (teardown !== null) {
+		const previously_destroying_effect = is_destroying_effect;
+		const previous_reaction = active_reaction;
+		set_is_destroying_effect(true);
+		set_active_reaction(null);
+		try {
+			teardown.call(null);
+		} finally {
+			set_is_destroying_effect(previously_destroying_effect);
+			set_active_reaction(previous_reaction);
+		}
+	}
+}
+
+/**
+ * @param {Effect} signal
+ * @param {boolean} remove_dom
+ * @returns {void}
+ */
+export function destroy_effect_children(signal, remove_dom = false) {
+	var effect = signal.first;
+	signal.first = signal.last = null;
+
+	while (effect !== null) {
+		const controller = effect.ac;
+
+		if (controller !== null) {
+			without_reactive_context(() => {
+				controller.abort(STALE_REACTION);
+			});
+		}
+
+		var next = effect.next;
+
+		if ((effect.f & ROOT_EFFECT) !== 0) {
+			// this is now an independent root
+			effect.parent = null;
+		} else {
+			destroy_effect(effect, remove_dom);
+		}
+
+		effect = next;
+	}
+}
+
+/**
+ * @param {Effect} signal
+ * @returns {void}
+ */
+export function destroy_block_effect_children(signal) {
+	var effect = signal.first;
+
+	while (effect !== null) {
+		var next = effect.next;
+		if ((effect.f & BRANCH_EFFECT) === 0) {
+			destroy_effect(effect);
+		}
+		effect = next;
+	}
+}
+
+/**
+ * @param {Effect} effect
+ * @param {boolean} [remove_dom]
+ * @returns {void}
+ */
+export function destroy_effect(effect, remove_dom = true) {
+	var removed = false;
+
+	if (
+		(remove_dom || (effect.f & HEAD_EFFECT) !== 0) &&
+		effect.nodes !== null &&
+		effect.nodes.end !== null
+	) {
+		remove_effect_dom(effect.nodes.start, /** @type {TemplateNode} */ (effect.nodes.end));
+		removed = true;
+	}
+
+	destroy_effect_children(effect, remove_dom && !removed);
+	remove_reactions(effect, 0);
+	set_signal_status(effect, DESTROYED);
+
+	var transitions = effect.nodes && effect.nodes.t;
+
+	if (transitions !== null) {
+		for (const transition of transitions) {
+			transition.stop();
+		}
+	}
+
+	execute_effect_teardown(effect);
+
+	var parent = effect.parent;
+
+	// If the parent doesn't have any children, then skip this work altogether
+	if (parent !== null && parent.first !== null) {
+		unlink_effect(effect);
+	}
+
+	if (DEV) {
+		effect.component_function = null;
+	}
+
+	// `first` and `child` are nulled out in destroy_effect_children
+	// we don't null out `parent` so that error propagation can work correctly
+	effect.next =
+		effect.prev =
+		effect.teardown =
+		effect.ctx =
+		effect.deps =
+		effect.fn =
+		effect.nodes =
+		effect.ac =
+			null;
+}
+
+/**
+ *
+ * @param {TemplateNode | null} node
+ * @param {TemplateNode} end
+ */
+export function remove_effect_dom(node, end) {
+	while (node !== null) {
+		/** @type {TemplateNode | null} */
+		var next = node === end ? null : get_next_sibling(node);
+
+		node.remove();
+		node = next;
+	}
+}
+
+/**
+ * Detach an effect from the effect tree, freeing up memory and
+ * reducing the amount of work that happens on subsequent traversals
+ * @param {Effect} effect
+ */
+export function unlink_effect(effect) {
+	var parent = effect.parent;
+	var prev = effect.prev;
+	var next = effect.next;
+
+	if (prev !== null) prev.next = next;
+	if (next !== null) next.prev = prev;
+
+	if (parent !== null) {
+		if (parent.first === effect) parent.first = next;
+		if (parent.last === effect) parent.last = prev;
+	}
+}
+
+/**
+ * When a block effect is removed, we don't immediately destroy it or yank it
+ * out of the DOM, because it might have transitions. Instead, we 'pause' it.
+ * It stays around (in memory, and in the DOM) until outro transitions have
+ * completed, and if the state change is reversed then we _resume_ it.
+ * A paused effect does not update, and the DOM subtree becomes inert.
+ * @param {Effect} effect
+ * @param {() => void} [callback]
+ * @param {boolean} [destroy]
+ */
+export function pause_effect(effect, callback, destroy = true) {
+	/** @type {TransitionManager[]} */
+	var transitions = [];
+
+	pause_children(effect, transitions, true);
+
+	var fn = () => {
+		if (destroy) destroy_effect(effect);
+		if (callback) callback();
+	};
+
+	var remaining = transitions.length;
+	if (remaining > 0) {
+		var check = () => --remaining || fn();
+		for (var transition of transitions) {
+			transition.out(check);
+		}
+	} else {
+		fn();
+	}
+}
+
+/**
+ * @param {Effect} effect
+ * @param {TransitionManager[]} transitions
+ * @param {boolean} local
+ */
+function pause_children(effect, transitions, local) {
+	if ((effect.f & INERT) !== 0) return;
+	effect.f ^= INERT;
+
+	var t = effect.nodes && effect.nodes.t;
+
+	if (t !== null) {
+		for (const transition of t) {
+			if (transition.is_global || local) {
+				transitions.push(transition);
+			}
+		}
+	}
+
+	var child = effect.first;
+
+	while (child !== null) {
+		var sibling = child.next;
+		var transparent =
+			(child.f & EFFECT_TRANSPARENT) !== 0 ||
+			// If this is a branch effect without a block effect parent,
+			// it means the parent block effect was pruned. In that case,
+			// transparency information was transferred to the branch effect.
+			((child.f & BRANCH_EFFECT) !== 0 && (effect.f & BLOCK_EFFECT) !== 0);
+		// TODO we don't need to call pause_children recursively with a linked list in place
+		// it's slightly more involved though as we have to account for `transparent` changing
+		// through the tree.
+		pause_children(child, transitions, transparent ? local : false);
+		child = sibling;
+	}
+}
+
+/**
+ * The opposite of `pause_effect`. We call this if (for example)
+ * `x` becomes falsy then truthy: `{#if x}...{/if}`
+ * @param {Effect} effect
+ */
+export function resume_effect(effect) {
+	resume_children(effect, true);
+}
+
+/**
+ * @param {Effect} effect
+ * @param {boolean} local
+ */
+function resume_children(effect, local) {
+	if ((effect.f & INERT) === 0) return;
+	effect.f ^= INERT;
+
+	// If a dependency of this effect changed while it was paused,
+	// schedule the effect to update. we don't use `is_dirty`
+	// here because we don't want to eagerly recompute a derived like
+	// `{#if foo}{foo.bar()}{/if}` if `foo` is now `undefined
+	if ((effect.f & CLEAN) === 0) {
+		set_signal_status(effect, DIRTY);
+		schedule_effect(effect);
+	}
+
+	var child = effect.first;
+
+	while (child !== null) {
+		var sibling = child.next;
+		var transparent = (child.f & EFFECT_TRANSPARENT) !== 0 || (child.f & BRANCH_EFFECT) !== 0;
+		// TODO we don't need to call resume_children recursively with a linked list in place
+		// it's slightly more involved though as we have to account for `transparent` changing
+		// through the tree.
+		resume_children(child, transparent ? local : false);
+		child = sibling;
+	}
+
+	var t = effect.nodes && effect.nodes.t;
+
+	if (t !== null) {
+		for (const transition of t) {
+			if (transition.is_global || local) {
+				transition.in();
+			}
+		}
+	}
+}
+
+export function aborted(effect = /** @type {Effect} */ (active_effect)) {
+	return (effect.f & DESTROYED) !== 0;
+}
+
+/**
+ * @param {Effect} effect
+ * @param {DocumentFragment} fragment
+ */
+export function move_effect(effect, fragment) {
+	if (!effect.nodes) return;
+
+	/** @type {TemplateNode | null} */
+	var node = effect.nodes.start;
+	var end = effect.nodes.end;
+
+	while (node !== null) {
+		/** @type {TemplateNode | null} */
+		var next = node === end ? null : get_next_sibling(node);
+
+		fragment.append(node);
+		node = next;
+	}
+}