lumen-plus 0.0.2 → 0.0.4

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

@@ -0,0 +1,368 @@
+/** @import { Derived, Effect, Source, Value } from '#client' */
+import { DEV } from 'esm-env';
+import {
+	active_reaction,
+	active_effect,
+	untracked_writes,
+	get,
+	set_untracked_writes,
+	untrack,
+	increment_write_version,
+	update_effect,
+	current_sources,
+	is_dirty,
+	untracking,
+	is_destroying_effect,
+	push_reaction_value
+} from '../runtime.js';
+import { equals, safe_equals } from './equality.js';
+import {
+	CLEAN,
+	DERIVED,
+	DIRTY,
+	BRANCH_EFFECT,
+	EAGER_EFFECT,
+	MAYBE_DIRTY,
+	BLOCK_EFFECT,
+	ROOT_EFFECT,
+	ASYNC,
+	WAS_MARKED,
+	CONNECTED
+} from '#client/constants';
+import * as e from '../errors.js';
+import { legacy_mode_flag, tracing_mode_flag } from '../../flags/index.js';
+import { tag_proxy } from '../dev/tracing.js';
+import { get_error } from '../../shared/dev.js';
+import { component_context, is_runes } from '../context.js';
+import { Batch, batch_values, eager_block_effects, schedule_effect } from './batch.js';
+import { proxy } from '../proxy.js';
+import { execute_derived } from './deriveds.js';
+import { set_signal_status, update_derived_status } from './status.js';
+
+/** @type {Set<any>} */
+export let eager_effects = new Set();
+
+/** @type {Map<Source, any>} */
+export const old_values = new Map();
+
+/**
+ * @param {Set<any>} v
+ */
+export function set_eager_effects(v) {
+	eager_effects = v;
+}
+
+let eager_effects_deferred = false;
+
+export function set_eager_effects_deferred() {
+	eager_effects_deferred = true;
+}
+
+/**
+ * @template V
+ * @param {V} v
+ * @param {Error | null} [stack]
+ * @returns {Source<V>}
+ */
+// TODO rename this to `state` throughout the codebase
+export function source(v, stack) {
+	/** @type {Value} */
+	var signal = {
+		f: 0, // TODO ideally we could skip this altogether, but it causes type errors
+		v,
+		reactions: null,
+		equals,
+		rv: 0,
+		wv: 0
+	};
+
+	if (DEV && tracing_mode_flag) {
+		signal.created = stack ?? get_error('created at');
+		signal.updated = null;
+		signal.set_during_effect = false;
+		signal.trace = null;
+	}
+
+	return signal;
+}
+
+/**
+ * @template V
+ * @param {V} v
+ * @param {Error | null} [stack]
+ */
+/*#__NO_SIDE_EFFECTS__*/
+export function state(v, stack) {
+	const s = source(v, stack);
+
+	push_reaction_value(s);
+
+	return s;
+}
+
+/**
+ * @template V
+ * @param {V} initial_value
+ * @param {boolean} [immutable]
+ * @returns {Source<V>}
+ */
+/*#__NO_SIDE_EFFECTS__*/
+export function mutable_source(initial_value, immutable = false, trackable = true) {
+	const s = source(initial_value);
+	if (!immutable) {
+		s.equals = safe_equals;
+	}
+
+	// bind the signal to the component context, in case we need to
+	// track updates to trigger beforeUpdate/afterUpdate callbacks
+	if (legacy_mode_flag && trackable && component_context !== null && component_context.l !== null) {
+		(component_context.l.s ??= []).push(s);
+	}
+
+	return s;
+}
+
+/**
+ * @template V
+ * @param {Value<V>} source
+ * @param {V} value
+ */
+export function mutate(source, value) {
+	set(
+		source,
+		untrack(() => get(source))
+	);
+	return value;
+}
+
+/**
+ * @template V
+ * @param {Source<V>} source
+ * @param {V} value
+ * @param {boolean} [should_proxy]
+ * @returns {V}
+ */
+export function set(source, value, should_proxy = false) {
+	if (
+		active_reaction !== null &&
+		// since we are untracking the function inside `$inspect.with` we need to add this check
+		// to ensure we error if state is set inside an inspect effect
+		(!untracking || (active_reaction.f & EAGER_EFFECT) !== 0) &&
+		is_runes() &&
+		(active_reaction.f & (DERIVED | BLOCK_EFFECT | ASYNC | EAGER_EFFECT)) !== 0 &&
+		!current_sources?.includes(source)
+	) {
+		e.state_unsafe_mutation();
+	}
+
+	let new_value = should_proxy ? proxy(value) : value;
+
+	if (DEV) {
+		tag_proxy(new_value, /** @type {string} */ (source.label));
+	}
+
+	return internal_set(source, new_value);
+}
+
+/**
+ * @template V
+ * @param {Source<V>} source
+ * @param {V} value
+ * @returns {V}
+ */
+export function internal_set(source, value) {
+	if (!source.equals(value)) {
+		var old_value = source.v;
+
+		if (is_destroying_effect) {
+			old_values.set(source, value);
+		} else {
+			old_values.set(source, old_value);
+		}
+
+		source.v = value;
+
+		var batch = Batch.ensure();
+		batch.capture(source, old_value);
+
+		if (DEV) {
+			if (tracing_mode_flag || active_effect !== null) {
+				source.updated ??= new Map();
+
+				// For performance reasons, when not using $inspect.trace, we only start collecting stack traces
+				// after the same source has been updated more than 5 times in the same flush cycle.
+				const count = (source.updated.get('')?.count ?? 0) + 1;
+				source.updated.set('', { error: /** @type {any} */ (null), count });
+
+				if (tracing_mode_flag || count > 5) {
+					const error = get_error('updated at');
+
+					if (error !== null) {
+						let entry = source.updated.get(error.stack);
+
+						if (!entry) {
+							entry = { error, count: 0 };
+							source.updated.set(error.stack, entry);
+						}
+
+						entry.count++;
+					}
+				}
+			}
+
+			if (active_effect !== null) {
+				source.set_during_effect = true;
+			}
+		}
+
+		if ((source.f & DERIVED) !== 0) {
+			const derived = /** @type {Derived} */ (source);
+
+			// if we are assigning to a dirty derived we set it to clean/maybe dirty but we also eagerly execute it to track the dependencies
+			if ((source.f & DIRTY) !== 0) {
+				execute_derived(derived);
+			}
+
+			update_derived_status(derived);
+		}
+
+		source.wv = increment_write_version();
+
+		// For debugging, in case you want to know which reactions are being scheduled:
+		// log_reactions(source);
+		mark_reactions(source, DIRTY);
+
+		// It's possible that the current reaction might not have up-to-date dependencies
+		// whilst it's actively running. So in the case of ensuring it registers the reaction
+		// properly for itself, we need to ensure the current effect actually gets
+		// scheduled. i.e: `$effect(() => x++)`
+		if (
+			is_runes() &&
+			active_effect !== null &&
+			(active_effect.f & CLEAN) !== 0 &&
+			(active_effect.f & (BRANCH_EFFECT | ROOT_EFFECT)) === 0
+		) {
+			if (untracked_writes === null) {
+				set_untracked_writes([source]);
+			} else {
+				untracked_writes.push(source);
+			}
+		}
+
+		if (!batch.is_fork && eager_effects.size > 0 && !eager_effects_deferred) {
+			flush_eager_effects();
+		}
+	}
+
+	return value;
+}
+
+export function flush_eager_effects() {
+	eager_effects_deferred = false;
+
+	for (const effect of eager_effects) {
+		// Mark clean inspect-effects as maybe dirty and then check their dirtiness
+		// instead of just updating the effects - this way we avoid overfiring.
+		if ((effect.f & CLEAN) !== 0) {
+			set_signal_status(effect, MAYBE_DIRTY);
+		}
+
+		if (is_dirty(effect)) {
+			update_effect(effect);
+		}
+	}
+
+	eager_effects.clear();
+}
+
+/**
+ * @template {number | bigint} T
+ * @param {Source<T>} source
+ * @param {1 | -1} [d]
+ * @returns {T}
+ */
+export function update(source, d = 1) {
+	var value = get(source);
+	var result = d === 1 ? value++ : value--;
+
+	set(source, value);
+
+	// @ts-expect-error
+	return result;
+}
+
+/**
+ * @template {number | bigint} T
+ * @param {Source<T>} source
+ * @param {1 | -1} [d]
+ * @returns {T}
+ */
+export function update_pre(source, d = 1) {
+	var value = get(source);
+
+	// @ts-expect-error
+	return set(source, d === 1 ? ++value : --value);
+}
+
+/**
+ * Silently (without using `get`) increment a source
+ * @param {Source<number>} source
+ */
+export function increment(source) {
+	set(source, source.v + 1);
+}
+
+/**
+ * @param {Value} signal
+ * @param {number} status should be DIRTY or MAYBE_DIRTY
+ * @returns {void}
+ */
+function mark_reactions(signal, status) {
+	var reactions = signal.reactions;
+	if (reactions === null) return;
+
+	var runes = is_runes();
+	var length = reactions.length;
+
+	for (var i = 0; i < length; i++) {
+		var reaction = reactions[i];
+		var flags = reaction.f;
+
+		// In legacy mode, skip the current effect to prevent infinite loops
+		if (!runes && reaction === active_effect) continue;
+
+		// Inspect effects need to run immediately, so that the stack trace makes sense
+		if (DEV && (flags & EAGER_EFFECT) !== 0) {
+			eager_effects.add(reaction);
+			continue;
+		}
+
+		var not_dirty = (flags & DIRTY) === 0;
+
+		// don't set a DIRTY reaction to MAYBE_DIRTY
+		if (not_dirty) {
+			set_signal_status(reaction, status);
+		}
+
+		if ((flags & DERIVED) !== 0) {
+			var derived = /** @type {Derived} */ (reaction);
+
+			batch_values?.delete(derived);
+
+			if ((flags & WAS_MARKED) === 0) {
+				// Only connected deriveds can be reliably unmarked right away
+				if (flags & CONNECTED) {
+					reaction.f |= WAS_MARKED;
+				}
+
+				mark_reactions(derived, MAYBE_DIRTY);
+			}
+		} else if (not_dirty) {
+			if ((flags & BLOCK_EFFECT) !== 0 && eager_block_effects !== null) {
+				eager_block_effects.add(/** @type {Effect} */ (reaction));
+			}
+
+			schedule_effect(/** @type {Effect} */ (reaction));
+		}
+	}
+}

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

@@ -0,0 +1,25 @@
+/** @import { Derived, Signal } from '#client' */
+import { CLEAN, CONNECTED, DIRTY, MAYBE_DIRTY } from '#client/constants';
+
+const STATUS_MASK = ~(DIRTY | MAYBE_DIRTY | CLEAN);
+
+/**
+ * @param {Signal} signal
+ * @param {number} status
+ */
+export function set_signal_status(signal, status) {
+	signal.f = (signal.f & STATUS_MASK) | status;
+}
+
+/**
+ * Set a derived's status to CLEAN or MAYBE_DIRTY based on its connection state.
+ * @param {Derived} derived
+ */
+export function update_derived_status(derived) {
+	// Only mark as MAYBE_DIRTY if disconnected and has dependencies.
+	if ((derived.f & CONNECTED) !== 0 || derived.deps === null) {
+		set_signal_status(derived, CLEAN);
+	} else {
+		set_signal_status(derived, MAYBE_DIRTY);
+	}
+}

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

@@ -0,0 +1,203 @@
+/** @import { StoreReferencesContainer } from '#client' */
+/** @import { Store } from '#shared' */
+import { subscribe_to_store } from '../../../store/utils.js';
+import { get as get_store } from '../../../store/shared/index.js';
+import { define_property, noop } from '../../shared/utils.js';
+import { get } from '../runtime.js';
+import { teardown } from './effects.js';
+import { mutable_source, set } from './sources.js';
+import { DEV } from 'esm-env';
+
+/**
+ * Whether or not the prop currently being read is a store binding, as in
+ * `<Child bind:x={$y} />`. If it is, we treat the prop as mutable even in
+ * runes mode, and skip `binding_property_non_reactive` validation
+ */
+let is_store_binding = false;
+
+let IS_UNMOUNTED = Symbol();
+
+/**
+ * Gets the current value of a store. If the store isn't subscribed to yet, it will create a proxy
+ * signal that will be updated when the store is. The store references container is needed to
+ * track reassignments to stores and to track the correct component context.
+ * @template V
+ * @param {Store<V> | null | undefined} store
+ * @param {string} store_name
+ * @param {StoreReferencesContainer} stores
+ * @returns {V}
+ */
+export function store_get(store, store_name, stores) {
+	const entry = (stores[store_name] ??= {
+		store: null,
+		source: mutable_source(undefined),
+		unsubscribe: noop
+	});
+
+	if (DEV) {
+		entry.source.label = store_name;
+	}
+
+	// if the component that setup this is already unmounted we don't want to register a subscription
+	if (entry.store !== store && !(IS_UNMOUNTED in stores)) {
+		entry.unsubscribe();
+		entry.store = store ?? null;
+
+		if (store == null) {
+			entry.source.v = undefined; // see synchronous callback comment below
+			entry.unsubscribe = noop;
+		} else {
+			var is_synchronous_callback = true;
+
+			entry.unsubscribe = subscribe_to_store(store, (v) => {
+				if (is_synchronous_callback) {
+					// If the first updates to the store value (possibly multiple of them) are synchronously
+					// inside a derived, we will hit the `state_unsafe_mutation` error if we `set` the value
+					entry.source.v = v;
+				} else {
+					set(entry.source, v);
+				}
+			});
+
+			is_synchronous_callback = false;
+		}
+	}
+
+	// if the component that setup this stores is already unmounted the source will be out of sync
+	// so we just use the `get` for the stores, less performant but it avoids to create a memory leak
+	// and it will keep the value consistent
+	if (store && IS_UNMOUNTED in stores) {
+		return get_store(store);
+	}
+
+	return get(entry.source);
+}
+
+/**
+ * Unsubscribe from a store if it's not the same as the one in the store references container.
+ * We need this in addition to `store_get` because someone could unsubscribe from a store but
+ * then never subscribe to the new one (if any), causing the subscription to stay open wrongfully.
+ * @param {Store<any> | null | undefined} store
+ * @param {string} store_name
+ * @param {StoreReferencesContainer} stores
+ */
+export function store_unsub(store, store_name, stores) {
+	/** @type {StoreReferencesContainer[''] | undefined} */
+	let entry = stores[store_name];
+
+	if (entry && entry.store !== store) {
+		// Don't reset store yet, so that store_get above can resubscribe to new store if necessary
+		entry.unsubscribe();
+		entry.unsubscribe = noop;
+	}
+
+	return store;
+}
+
+/**
+ * Sets the new value of a store and returns that value.
+ * @template V
+ * @param {Store<V>} store
+ * @param {V} value
+ * @returns {V}
+ */
+export function store_set(store, value) {
+	store.set(value);
+	return value;
+}
+
+/**
+ * @param {StoreReferencesContainer} stores
+ * @param {string} store_name
+ */
+export function invalidate_store(stores, store_name) {
+	var entry = stores[store_name];
+	if (entry.store !== null) {
+		store_set(entry.store, entry.source.v);
+	}
+}
+
+/**
+ * Unsubscribes from all auto-subscribed stores on destroy
+ * @returns {[StoreReferencesContainer, ()=>void]}
+ */
+export function setup_stores() {
+	/** @type {StoreReferencesContainer} */
+	const stores = {};
+
+	function cleanup() {
+		teardown(() => {
+			for (var store_name in stores) {
+				const ref = stores[store_name];
+				ref.unsubscribe();
+			}
+			define_property(stores, IS_UNMOUNTED, {
+				enumerable: false,
+				value: true
+			});
+		});
+	}
+
+	return [stores, cleanup];
+}
+
+/**
+ * Updates a store with a new value.
+ * @param {Store<V>} store  the store to update
+ * @param {any} expression  the expression that mutates the store
+ * @param {V} new_value  the new store value
+ * @template V
+ */
+export function store_mutate(store, expression, new_value) {
+	store.set(new_value);
+	return expression;
+}
+
+/**
+ * @param {Store<number>} store
+ * @param {number} store_value
+ * @param {1 | -1} [d]
+ * @returns {number}
+ */
+export function update_store(store, store_value, d = 1) {
+	store.set(store_value + d);
+	return store_value;
+}
+
+/**
+ * @param {Store<number>} store
+ * @param {number} store_value
+ * @param {1 | -1} [d]
+ * @returns {number}
+ */
+export function update_pre_store(store, store_value, d = 1) {
+	const value = store_value + d;
+	store.set(value);
+	return value;
+}
+
+/**
+ * Called inside prop getters to communicate that the prop is a store binding
+ */
+export function mark_store_binding() {
+	is_store_binding = true;
+}
+
+/**
+ * Returns a tuple that indicates whether `fn()` reads a prop that is a store binding.
+ * Used to prevent `binding_property_non_reactive` validation false positives and
+ * ensure that these props are treated as mutable even in runes mode
+ * @template T
+ * @param {() => T} fn
+ * @returns {[T, boolean]}
+ */
+export function capture_store_binding(fn) {
+	var previous_is_store_binding = is_store_binding;
+
+	try {
+		is_store_binding = false;
+		return [fn(), is_store_binding];
+	} finally {
+		is_store_binding = previous_is_store_binding;
+	}
+}

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

@@ -0,0 +1,40 @@
+/** @import { Derived, Effect, Value } from '#client' */
+import { CLEAN, DERIVED, DIRTY, MAYBE_DIRTY, WAS_MARKED } from '#client/constants';
+import { set_signal_status } from './status.js';
+
+/**
+ * @param {Value[] | null} deps
+ */
+function clear_marked(deps) {
+	if (deps === null) return;
+
+	for (const dep of deps) {
+		if ((dep.f & DERIVED) === 0 || (dep.f & WAS_MARKED) === 0) {
+			continue;
+		}
+
+		dep.f ^= WAS_MARKED;
+
+		clear_marked(/** @type {Derived} */ (dep).deps);
+	}
+}
+
+/**
+ * @param {Effect} effect
+ * @param {Set<Effect>} dirty_effects
+ * @param {Set<Effect>} maybe_dirty_effects
+ */
+export function defer_effect(effect, dirty_effects, maybe_dirty_effects) {
+	if ((effect.f & DIRTY) !== 0) {
+		dirty_effects.add(effect);
+	} else if ((effect.f & MAYBE_DIRTY) !== 0) {
+		maybe_dirty_effects.add(effect);
+	}
+
+	// Since we're not executing these effects now, we need to clear any WAS_MARKED flags
+	// so that other batches can correctly reach these effects during their own traversal
+	clear_marked(effect.deps);
+
+	// mark as clean so they get scheduled if they depend on pending async state
+	set_signal_status(effect, CLEAN);
+}