lumen-plus 0.0.4 → 0.0.5

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

@@ -1,368 +0,0 @@
-/** @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

@@ -1,25 +0,0 @@
-/** @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

@@ -1,203 +0,0 @@
-/** @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

@@ -1,40 +0,0 @@
-/** @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);
-}