svelte-on-rails 0.0.30 → 0.0.31

data/lib/svelte_on_rails/node_modules/svelte/src/internal/client/reactivity/props.js

@@ -1,427 +0,0 @@
-/** @import { Derived, Source } from './types.js' */
-import { DEV } from 'esm-env';
-import {
-	PROPS_IS_BINDABLE,
-	PROPS_IS_IMMUTABLE,
-	PROPS_IS_LAZY_INITIAL,
-	PROPS_IS_RUNES,
-	PROPS_IS_UPDATED
-} from '../../../constants.js';
-import { define_property, get_descriptor, is_function } from '../../shared/utils.js';
-import { mutable_source, set, source, update } from './sources.js';
-import { derived, derived_safe_equal } from './deriveds.js';
-import { get, captured_signals, untrack } from '../runtime.js';
-import { safe_equals } from './equality.js';
-import * as e from '../errors.js';
-import { LEGACY_DERIVED_PROP, LEGACY_PROPS, STATE_SYMBOL } from '../constants.js';
-import { proxy } from '../proxy.js';
-import { capture_store_binding } from './store.js';
-import { legacy_mode_flag } from '../../flags/index.js';
-
-/**
- * @param {((value?: number) => number)} fn
- * @param {1 | -1} [d]
- * @returns {number}
- */
-export function update_prop(fn, d = 1) {
-	const value = fn();
-	fn(value + d);
-	return value;
-}
-
-/**
- * @param {((value?: number) => number)} fn
- * @param {1 | -1} [d]
- * @returns {number}
- */
-export function update_pre_prop(fn, d = 1) {
-	const value = fn() + d;
-	fn(value);
-	return value;
-}
-
-/**
- * The proxy handler for rest props (i.e. `const { x, ...rest } = $props()`).
- * Is passed the full `$$props` object and excludes the named props.
- * @type {ProxyHandler<{ props: Record<string | symbol, unknown>, exclude: Array<string | symbol>, name?: string }>}}
- */
-const rest_props_handler = {
-	get(target, key) {
-		if (target.exclude.includes(key)) return;
-		return target.props[key];
-	},
-	set(target, key) {
-		if (DEV) {
-			// TODO should this happen in prod too?
-			e.props_rest_readonly(`${target.name}.${String(key)}`);
-		}
-
-		return false;
-	},
-	getOwnPropertyDescriptor(target, key) {
-		if (target.exclude.includes(key)) return;
-		if (key in target.props) {
-			return {
-				enumerable: true,
-				configurable: true,
-				value: target.props[key]
-			};
-		}
-	},
-	has(target, key) {
-		if (target.exclude.includes(key)) return false;
-		return key in target.props;
-	},
-	ownKeys(target) {
-		return Reflect.ownKeys(target.props).filter((key) => !target.exclude.includes(key));
-	}
-};
-
-/**
- * @param {Record<string, unknown>} props
- * @param {string[]} exclude
- * @param {string} [name]
- * @returns {Record<string, unknown>}
- */
-/*#__NO_SIDE_EFFECTS__*/
-export function rest_props(props, exclude, name) {
-	return new Proxy(
-		DEV ? { props, exclude, name, other: {}, to_proxy: [] } : { props, exclude },
-		rest_props_handler
-	);
-}
-
-/**
- * The proxy handler for legacy $$restProps and $$props
- * @type {ProxyHandler<{ props: Record<string | symbol, unknown>, exclude: Array<string | symbol>, special: Record<string | symbol, (v?: unknown) => unknown>, version: Source<number> }>}}
- */
-const legacy_rest_props_handler = {
-	get(target, key) {
-		if (target.exclude.includes(key)) return;
-		get(target.version);
-		return key in target.special ? target.special[key]() : target.props[key];
-	},
-	set(target, key, value) {
-		if (!(key in target.special)) {
-			// Handle props that can temporarily get out of sync with the parent
-			/** @type {Record<string, (v?: unknown) => unknown>} */
-			target.special[key] = prop(
-				{
-					get [key]() {
-						return target.props[key];
-					}
-				},
-				/** @type {string} */ (key),
-				PROPS_IS_UPDATED
-			);
-		}
-
-		target.special[key](value);
-		update(target.version); // $$props is coarse-grained: when $$props.x is updated, usages of $$props.y etc are also rerun
-		return true;
-	},
-	getOwnPropertyDescriptor(target, key) {
-		if (target.exclude.includes(key)) return;
-		if (key in target.props) {
-			return {
-				enumerable: true,
-				configurable: true,
-				value: target.props[key]
-			};
-		}
-	},
-	deleteProperty(target, key) {
-		// Svelte 4 allowed for deletions on $$restProps
-		if (target.exclude.includes(key)) return true;
-		target.exclude.push(key);
-		update(target.version);
-		return true;
-	},
-	has(target, key) {
-		if (target.exclude.includes(key)) return false;
-		return key in target.props;
-	},
-	ownKeys(target) {
-		return Reflect.ownKeys(target.props).filter((key) => !target.exclude.includes(key));
-	}
-};
-
-/**
- * @param {Record<string, unknown>} props
- * @param {string[]} exclude
- * @returns {Record<string, unknown>}
- */
-export function legacy_rest_props(props, exclude) {
-	return new Proxy({ props, exclude, special: {}, version: source(0) }, legacy_rest_props_handler);
-}
-
-/**
- * The proxy handler for spread props. Handles the incoming array of props
- * that looks like `() => { dynamic: props }, { static: prop }, ..` and wraps
- * them so that the whole thing is passed to the component as the `$$props` argument.
- * @template {Record<string | symbol, unknown>} T
- * @type {ProxyHandler<{ props: Array<T | (() => T)> }>}}
- */
-const spread_props_handler = {
-	get(target, key) {
-		let i = target.props.length;
-		while (i--) {
-			let p = target.props[i];
-			if (is_function(p)) p = p();
-			if (typeof p === 'object' && p !== null && key in p) return p[key];
-		}
-	},
-	set(target, key, value) {
-		let i = target.props.length;
-		while (i--) {
-			let p = target.props[i];
-			if (is_function(p)) p = p();
-			const desc = get_descriptor(p, key);
-			if (desc && desc.set) {
-				desc.set(value);
-				return true;
-			}
-		}
-		return false;
-	},
-	getOwnPropertyDescriptor(target, key) {
-		let i = target.props.length;
-		while (i--) {
-			let p = target.props[i];
-			if (is_function(p)) p = p();
-			if (typeof p === 'object' && p !== null && key in p) {
-				const descriptor = get_descriptor(p, key);
-				if (descriptor && !descriptor.configurable) {
-					// Prevent a "Non-configurability Report Error": The target is an array, it does
-					// not actually contain this property. If it is now described as non-configurable,
-					// the proxy throws a validation error. Setting it to true avoids that.
-					descriptor.configurable = true;
-				}
-				return descriptor;
-			}
-		}
-	},
-	has(target, key) {
-		// To prevent a false positive `is_entry_props` in the `prop` function
-		if (key === STATE_SYMBOL || key === LEGACY_PROPS) return false;
-
-		for (let p of target.props) {
-			if (is_function(p)) p = p();
-			if (p != null && key in p) return true;
-		}
-
-		return false;
-	},
-	ownKeys(target) {
-		/** @type {Array<string | symbol>} */
-		const keys = [];
-
-		for (let p of target.props) {
-			if (is_function(p)) p = p();
-			for (const key in p) {
-				if (!keys.includes(key)) keys.push(key);
-			}
-		}
-
-		return keys;
-	}
-};
-
-/**
- * @param {Array<Record<string, unknown> | (() => Record<string, unknown>)>} props
- * @returns {any}
- */
-export function spread_props(...props) {
-	return new Proxy({ props }, spread_props_handler);
-}
-
-/**
- * @param {Derived} current_value
- * @returns {boolean}
- */
-function has_destroyed_component_ctx(current_value) {
-	return current_value.ctx?.d ?? false;
-}
-
-/**
- * This function is responsible for synchronizing a possibly bound prop with the inner component state.
- * It is used whenever the compiler sees that the component writes to the prop, or when it has a default prop_value.
- * @template V
- * @param {Record<string, unknown>} props
- * @param {string} key
- * @param {number} flags
- * @param {V | (() => V)} [fallback]
- * @returns {(() => V | ((arg: V) => V) | ((arg: V, mutation: boolean) => V))}
- */
-export function prop(props, key, flags, fallback) {
-	var immutable = (flags & PROPS_IS_IMMUTABLE) !== 0;
-	var runes = !legacy_mode_flag || (flags & PROPS_IS_RUNES) !== 0;
-	var bindable = (flags & PROPS_IS_BINDABLE) !== 0;
-	var lazy = (flags & PROPS_IS_LAZY_INITIAL) !== 0;
-	var is_store_sub = false;
-	var prop_value;
-
-	if (bindable) {
-		[prop_value, is_store_sub] = capture_store_binding(() => /** @type {V} */ (props[key]));
-	} else {
-		prop_value = /** @type {V} */ (props[key]);
-	}
-
-	// Can be the case when someone does `mount(Component, props)` with `let props = $state({...})`
-	// or `createClassComponent(Component, props)`
-	var is_entry_props = STATE_SYMBOL in props || LEGACY_PROPS in props;
-
-	var setter =
-		(bindable &&
-			(get_descriptor(props, key)?.set ??
-				(is_entry_props && key in props && ((v) => (props[key] = v))))) ||
-		undefined;
-
-	var fallback_value = /** @type {V} */ (fallback);
-	var fallback_dirty = true;
-	var fallback_used = false;
-
-	var get_fallback = () => {
-		fallback_used = true;
-		if (fallback_dirty) {
-			fallback_dirty = false;
-			if (lazy) {
-				fallback_value = untrack(/** @type {() => V} */ (fallback));
-			} else {
-				fallback_value = /** @type {V} */ (fallback);
-			}
-		}
-
-		return fallback_value;
-	};
-
-	if (prop_value === undefined && fallback !== undefined) {
-		if (setter && runes) {
-			e.props_invalid_value(key);
-		}
-
-		prop_value = get_fallback();
-		if (setter) setter(prop_value);
-	}
-
-	/** @type {() => V} */
-	var getter;
-	if (runes) {
-		getter = () => {
-			var value = /** @type {V} */ (props[key]);
-			if (value === undefined) return get_fallback();
-			fallback_dirty = true;
-			fallback_used = false;
-			return value;
-		};
-	} else {
-		// Svelte 4 did not trigger updates when a primitive value was updated to the same value.
-		// Replicate that behavior through using a derived
-		var derived_getter = (immutable ? derived : derived_safe_equal)(
-			() => /** @type {V} */ (props[key])
-		);
-		derived_getter.f |= LEGACY_DERIVED_PROP;
-		getter = () => {
-			var value = get(derived_getter);
-			if (value !== undefined) fallback_value = /** @type {V} */ (undefined);
-			return value === undefined ? fallback_value : value;
-		};
-	}
-
-	// easy mode — prop is never written to
-	if ((flags & PROPS_IS_UPDATED) === 0) {
-		return getter;
-	}
-
-	// intermediate mode — prop is written to, but the parent component had
-	// `bind:foo` which means we can just call `$$props.foo = value` directly
-	if (setter) {
-		var legacy_parent = props.$$legacy;
-		return function (/** @type {any} */ value, /** @type {boolean} */ mutation) {
-			if (arguments.length > 0) {
-				// We don't want to notify if the value was mutated and the parent is in runes mode.
-				// In that case the state proxy (if it exists) should take care of the notification.
-				// If the parent is not in runes mode, we need to notify on mutation, too, that the prop
-				// has changed because the parent will not be able to detect the change otherwise.
-				if (!runes || !mutation || legacy_parent || is_store_sub) {
-					/** @type {Function} */ (setter)(mutation ? getter() : value);
-				}
-				return value;
-			} else {
-				return getter();
-			}
-		};
-	}
-
-	// hard mode. this is where it gets ugly — the value in the child should
-	// synchronize with the parent, but it should also be possible to temporarily
-	// set the value to something else locally.
-	var from_child = false;
-	var was_from_child = false;
-
-	// The derived returns the current value. The underlying mutable
-	// source is written to from various places to persist this value.
-	var inner_current_value = mutable_source(prop_value);
-	var current_value = derived(() => {
-		var parent_value = getter();
-		var child_value = get(inner_current_value);
-
-		if (from_child) {
-			from_child = false;
-			was_from_child = true;
-			return child_value;
-		}
-
-		was_from_child = false;
-		return (inner_current_value.v = parent_value);
-	});
-
-	// Ensure we eagerly capture the initial value if it's bindable
-	if (bindable) {
-		get(current_value);
-	}
-
-	if (!immutable) current_value.equals = safe_equals;
-
-	return function (/** @type {any} */ value, /** @type {boolean} */ mutation) {
-		// legacy nonsense — need to ensure the source is invalidated when necessary
-		// also needed for when handling inspect logic so we can inspect the correct source signal
-		if (captured_signals !== null) {
-			// set this so that we don't reset to the parent value if `d`
-			// is invalidated because of `invalidate_inner_signals` (rather
-			// than because the parent or child value changed)
-			from_child = was_from_child;
-			// invoke getters so that signals are picked up by `invalidate_inner_signals`
-			getter();
-			get(inner_current_value);
-		}
-
-		if (arguments.length > 0) {
-			const new_value = mutation ? get(current_value) : runes && bindable ? proxy(value) : value;
-
-			if (!current_value.equals(new_value)) {
-				from_child = true;
-				set(inner_current_value, new_value);
-				// To ensure the fallback value is consistent when used with proxies, we
-				// update the local fallback_value, but only if the fallback is actively used
-				if (fallback_used && fallback_value !== undefined) {
-					fallback_value = new_value;
-				}
-
-				if (has_destroyed_component_ctx(current_value)) {
-					return value;
-				}
-
-				untrack(() => get(current_value)); // force a synchronisation immediately
-			}
-
-			return value;
-		}
-
-		if (has_destroyed_component_ctx(current_value)) {
-			return current_value.v;
-		}
-
-		return get(current_value);
-	};
-}

data/lib/svelte_on_rails/node_modules/svelte/src/internal/client/reactivity/sources.js

@@ -1,291 +0,0 @@
-/** @import { Derived, Effect, Source, Value } from '#client' */
-import { DEV } from 'esm-env';
-import {
-	active_reaction,
-	active_effect,
-	untracked_writes,
-	get,
-	schedule_effect,
-	set_untracked_writes,
-	set_signal_status,
-	untrack,
-	increment_write_version,
-	update_effect,
-	reaction_sources,
-	check_dirtiness,
-	untracking,
-	is_destroying_effect,
-	push_reaction_value
-} from '../runtime.js';
-import { equals, safe_equals } from './equality.js';
-import {
-	CLEAN,
-	DERIVED,
-	DIRTY,
-	BRANCH_EFFECT,
-	INSPECT_EFFECT,
-	UNOWNED,
-	MAYBE_DIRTY,
-	BLOCK_EFFECT,
-	ROOT_EFFECT
-} from '../constants.js';
-import * as e from '../errors.js';
-import { legacy_mode_flag, tracing_mode_flag } from '../../flags/index.js';
-import { get_stack } from '../dev/tracing.js';
-import { component_context, is_runes } from '../context.js';
-import { proxy } from '../proxy.js';
-import { execute_derived } from './deriveds.js';
-
-export let inspect_effects = new Set();
-export const old_values = new Map();
-
-/**
- * @param {Set<any>} v
- */
-export function set_inspect_effects(v) {
-	inspect_effects = v;
-}
-
-/**
- * @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_stack('CreatedAt');
-		signal.debug = 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) {
-	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 && 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 &&
-		!untracking &&
-		is_runes() &&
-		(active_reaction.f & (DERIVED | BLOCK_EFFECT)) !== 0 &&
-		!reaction_sources?.includes(source)
-	) {
-		e.state_unsafe_mutation();
-	}
-
-	let new_value = should_proxy ? proxy(value) : value;
-
-	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;
-
-		if (DEV && tracing_mode_flag) {
-			source.updated = get_stack('UpdatedAt');
-			if (active_effect != null) {
-				source.trace_need_increase = true;
-				source.trace_v ??= old_value;
-			}
-		}
-
-		if ((source.f & DERIVED) !== 0) {
-			// 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(/** @type {Derived} */ (source));
-			}
-			set_signal_status(source, (source.f & UNOWNED) === 0 ? CLEAN : MAYBE_DIRTY);
-		}
-
-		source.wv = increment_write_version();
-
-		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 (DEV && inspect_effects.size > 0) {
-			const inspects = Array.from(inspect_effects);
-
-			for (const effect of inspects) {
-				// 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 (check_dirtiness(effect)) {
-					update_effect(effect);
-				}
-			}
-
-			inspect_effects.clear();
-		}
-	}
-
-	return value;
-}
-
-/**
- * @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);
-}
-
-/**
- * @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;
-
-		// Skip any effects that are already dirty
-		if ((flags & DIRTY) !== 0) continue;
-
-		// 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 & INSPECT_EFFECT) !== 0) {
-			inspect_effects.add(reaction);
-			continue;
-		}
-
-		set_signal_status(reaction, status);
-
-		// If the signal a) was previously clean or b) is an unowned derived, then mark it
-		if ((flags & (CLEAN | UNOWNED)) !== 0) {
-			if ((flags & DERIVED) !== 0) {
-				mark_reactions(/** @type {Derived} */ (reaction), MAYBE_DIRTY);
-			} else {
-				schedule_effect(/** @type {Effect} */ (reaction));
-			}
-		}
-	}
-}