svelte-on-rails 0.0.1

data/lib/mount_svelte/node_modules/svelte/src/internal/client/index.js

@@ -0,0 +1,163 @@
+export { FILENAME, HMR, NAMESPACE_SVG } from '../../constants.js';
+export { push, pop } from './context.js';
+export { assign, assign_and, assign_or, assign_nullish } from './dev/assign.js';
+export { cleanup_styles } from './dev/css.js';
+export { add_locations } from './dev/elements.js';
+export { hmr } from './dev/hmr.js';
+export { create_ownership_validator } from './dev/ownership.js';
+export { check_target, legacy_api } from './dev/legacy.js';
+export { trace } from './dev/tracing.js';
+export { inspect } from './dev/inspect.js';
+export { validate_snippet_args } from './dev/validation.js';
+export { await_block as await } from './dom/blocks/await.js';
+export { if_block as if } from './dom/blocks/if.js';
+export { key_block as key } from './dom/blocks/key.js';
+export { css_props } from './dom/blocks/css-props.js';
+export { index, each } from './dom/blocks/each.js';
+export { html } from './dom/blocks/html.js';
+export { sanitize_slots, slot } from './dom/blocks/slot.js';
+export { snippet, wrap_snippet } from './dom/blocks/snippet.js';
+export { component } from './dom/blocks/svelte-component.js';
+export { element } from './dom/blocks/svelte-element.js';
+export { head } from './dom/blocks/svelte-head.js';
+export { append_styles } from './dom/css.js';
+export { action } from './dom/elements/actions.js';
+export {
+	remove_input_defaults,
+	set_attribute,
+	set_attributes,
+	set_custom_element_data,
+	set_xlink_attribute,
+	set_value,
+	set_checked,
+	set_selected,
+	set_default_checked,
+	set_default_value,
+	CLASS,
+	STYLE
+} from './dom/elements/attributes.js';
+export { set_class } from './dom/elements/class.js';
+export { apply, event, delegate, replay_events } from './dom/elements/events.js';
+export { autofocus, remove_textarea_child } from './dom/elements/misc.js';
+export { set_style } from './dom/elements/style.js';
+export { animation, transition } from './dom/elements/transitions.js';
+export { bind_active_element } from './dom/elements/bindings/document.js';
+export { bind_checked, bind_files, bind_group, bind_value } from './dom/elements/bindings/input.js';
+export {
+	bind_buffered,
+	bind_current_time,
+	bind_ended,
+	bind_muted,
+	bind_paused,
+	bind_playback_rate,
+	bind_played,
+	bind_ready_state,
+	bind_seekable,
+	bind_seeking,
+	bind_volume
+} from './dom/elements/bindings/media.js';
+export { bind_online } from './dom/elements/bindings/navigator.js';
+export { bind_prop } from './dom/elements/bindings/props.js';
+export { bind_select_value, init_select, select_option } from './dom/elements/bindings/select.js';
+export { bind_element_size, bind_resize_observer } from './dom/elements/bindings/size.js';
+export { bind_this } from './dom/elements/bindings/this.js';
+export {
+	bind_content_editable,
+	bind_property,
+	bind_focused
+} from './dom/elements/bindings/universal.js';
+export { bind_window_scroll, bind_window_size } from './dom/elements/bindings/window.js';
+export { hydrate_template, next, reset } from './dom/hydration.js';
+export {
+	once,
+	preventDefault,
+	self,
+	stopImmediatePropagation,
+	stopPropagation,
+	trusted
+} from './dom/legacy/event-modifiers.js';
+export { init } from './dom/legacy/lifecycle.js';
+export {
+	add_legacy_event_listener,
+	bubble_event,
+	reactive_import,
+	update_legacy_props
+} from './dom/legacy/misc.js';
+export {
+	append,
+	comment,
+	ns_template,
+	svg_template_with_script,
+	mathml_template,
+	template,
+	template_with_script,
+	text,
+	props_id
+} from './dom/template.js';
+export { user_derived as derived, derived_safe_equal } from './reactivity/deriveds.js';
+export {
+	effect_tracking,
+	effect_root,
+	legacy_pre_effect,
+	legacy_pre_effect_reset,
+	render_effect,
+	template_effect,
+	effect,
+	user_effect,
+	user_pre_effect
+} from './reactivity/effects.js';
+export { mutable_source, mutate, set, state, update, update_pre } from './reactivity/sources.js';
+export {
+	prop,
+	rest_props,
+	legacy_rest_props,
+	spread_props,
+	update_pre_prop,
+	update_prop
+} from './reactivity/props.js';
+export {
+	invalidate_store,
+	store_mutate,
+	setup_stores,
+	store_get,
+	store_set,
+	store_unsub,
+	update_pre_store,
+	update_store,
+	mark_store_binding
+} from './reactivity/store.js';
+export { boundary } from './dom/blocks/boundary.js';
+export { set_text } from './render.js';
+export {
+	get,
+	safe_get,
+	invalidate_inner_signals,
+	flushSync as flush,
+	tick,
+	untrack,
+	exclude_from_object,
+	deep_read,
+	deep_read_state
+} from './runtime.js';
+export { validate_binding, validate_each_keys } from './validate.js';
+export { raf } from './timing.js';
+export { proxy } from './proxy.js';
+export { create_custom_element } from './dom/elements/custom-element.js';
+export {
+	child,
+	first_child,
+	sibling,
+	$window as window,
+	$document as document
+} from './dom/operations.js';
+export { attr, clsx } from '../shared/attributes.js';
+export { snapshot } from '../shared/clone.js';
+export { noop, fallback } from '../shared/utils.js';
+export {
+	invalid_default_snippet,
+	validate_dynamic_element_tag,
+	validate_store,
+	validate_void_dynamic_element
+} from '../shared/validate.js';
+export { strict_equals, equals } from './dev/equality.js';
+export { log_if_contains_state } from './dev/console-log.js';

data/lib/mount_svelte/node_modules/svelte/src/internal/client/loop.js

@@ -0,0 +1,48 @@
+/** @import { TaskCallback, Task, TaskEntry } from '#client' */
+import { raf } from './timing.js';
+
+// TODO move this into timing.js where it probably belongs
+
+/**
+ * @returns {void}
+ */
+function run_tasks() {
+	// use `raf.now()` instead of the `requestAnimationFrame` callback argument, because
+	// otherwise things can get wonky https://github.com/sveltejs/svelte/pull/14541
+	const now = raf.now();
+
+	raf.tasks.forEach((task) => {
+		if (!task.c(now)) {
+			raf.tasks.delete(task);
+			task.f();
+		}
+	});
+
+	if (raf.tasks.size !== 0) {
+		raf.tick(run_tasks);
+	}
+}
+
+/**
+ * Creates a new task that runs on each raf frame
+ * until it returns a falsy value or is aborted
+ * @param {TaskCallback} callback
+ * @returns {Task}
+ */
+export function loop(callback) {
+	/** @type {TaskEntry} */
+	let task;
+
+	if (raf.tasks.size === 0) {
+		raf.tick(run_tasks);
+	}
+
+	return {
+		promise: new Promise((fulfill) => {
+			raf.tasks.add((task = { c: callback, f: fulfill }));
+		}),
+		abort() {
+			raf.tasks.delete(task);
+		}
+	};
+}

data/lib/mount_svelte/node_modules/svelte/src/internal/client/proxy.js

@@ -0,0 +1,319 @@
+/** @import { Source } from '#client' */
+import { DEV } from 'esm-env';
+import { get, active_effect, active_reaction, set_active_reaction } from './runtime.js';
+import {
+	array_prototype,
+	get_descriptor,
+	get_prototype_of,
+	is_array,
+	object_prototype
+} from '../shared/utils.js';
+import { state as source, set } from './reactivity/sources.js';
+import { STATE_SYMBOL } from './constants.js';
+import { UNINITIALIZED } from '../../constants.js';
+import * as e from './errors.js';
+import { get_stack } from './dev/tracing.js';
+import { tracing_mode_flag } from '../flags/index.js';
+
+/**
+ * @template T
+ * @param {T} value
+ * @returns {T}
+ */
+export function proxy(value) {
+	// if non-proxyable, or is already a proxy, return `value`
+	if (typeof value !== 'object' || value === null || STATE_SYMBOL in value) {
+		return value;
+	}
+
+	const prototype = get_prototype_of(value);
+
+	if (prototype !== object_prototype && prototype !== array_prototype) {
+		return value;
+	}
+
+	/** @type {Map<any, Source<any>>} */
+	var sources = new Map();
+	var is_proxied_array = is_array(value);
+	var version = source(0);
+
+	var stack = DEV && tracing_mode_flag ? get_stack('CreatedAt') : null;
+	var reaction = active_reaction;
+
+	/**
+	 * @template T
+	 * @param {() => T} fn
+	 */
+	var with_parent = (fn) => {
+		var previous_reaction = active_reaction;
+		set_active_reaction(reaction);
+
+		/** @type {T} */
+		var result = fn();
+
+		set_active_reaction(previous_reaction);
+		return result;
+	};
+
+	if (is_proxied_array) {
+		// We need to create the length source eagerly to ensure that
+		// mutations to the array are properly synced with our proxy
+		sources.set('length', source(/** @type {any[]} */ (value).length, stack));
+	}
+
+	return new Proxy(/** @type {any} */ (value), {
+		defineProperty(_, prop, descriptor) {
+			if (
+				!('value' in descriptor) ||
+				descriptor.configurable === false ||
+				descriptor.enumerable === false ||
+				descriptor.writable === false
+			) {
+				// we disallow non-basic descriptors, because unless they are applied to the
+				// target object — which we avoid, so that state can be forked — we will run
+				// afoul of the various invariants
+				// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Proxy/Proxy/getOwnPropertyDescriptor#invariants
+				e.state_descriptors_fixed();
+			}
+
+			var s = sources.get(prop);
+
+			if (s === undefined) {
+				s = with_parent(() => source(descriptor.value, stack));
+				sources.set(prop, s);
+			} else {
+				set(
+					s,
+					with_parent(() => proxy(descriptor.value))
+				);
+			}
+
+			return true;
+		},
+
+		deleteProperty(target, prop) {
+			var s = sources.get(prop);
+
+			if (s === undefined) {
+				if (prop in target) {
+					sources.set(
+						prop,
+						with_parent(() => source(UNINITIALIZED, stack))
+					);
+				}
+			} else {
+				// When working with arrays, we need to also ensure we update the length when removing
+				// an indexed property
+				if (is_proxied_array && typeof prop === 'string') {
+					var ls = /** @type {Source<number>} */ (sources.get('length'));
+					var n = Number(prop);
+
+					if (Number.isInteger(n) && n < ls.v) {
+						set(ls, n);
+					}
+				}
+				set(s, UNINITIALIZED);
+				update_version(version);
+			}
+
+			return true;
+		},
+
+		get(target, prop, receiver) {
+			if (prop === STATE_SYMBOL) {
+				return value;
+			}
+
+			var s = sources.get(prop);
+			var exists = prop in target;
+
+			// create a source, but only if it's an own property and not a prototype property
+			if (s === undefined && (!exists || get_descriptor(target, prop)?.writable)) {
+				s = with_parent(() => source(proxy(exists ? target[prop] : UNINITIALIZED), stack));
+				sources.set(prop, s);
+			}
+
+			if (s !== undefined) {
+				var v = get(s);
+				return v === UNINITIALIZED ? undefined : v;
+			}
+
+			return Reflect.get(target, prop, receiver);
+		},
+
+		getOwnPropertyDescriptor(target, prop) {
+			var descriptor = Reflect.getOwnPropertyDescriptor(target, prop);
+
+			if (descriptor && 'value' in descriptor) {
+				var s = sources.get(prop);
+				if (s) descriptor.value = get(s);
+			} else if (descriptor === undefined) {
+				var source = sources.get(prop);
+				var value = source?.v;
+
+				if (source !== undefined && value !== UNINITIALIZED) {
+					return {
+						enumerable: true,
+						configurable: true,
+						value,
+						writable: true
+					};
+				}
+			}
+
+			return descriptor;
+		},
+
+		has(target, prop) {
+			if (prop === STATE_SYMBOL) {
+				return true;
+			}
+
+			var s = sources.get(prop);
+			var has = (s !== undefined && s.v !== UNINITIALIZED) || Reflect.has(target, prop);
+
+			if (
+				s !== undefined ||
+				(active_effect !== null && (!has || get_descriptor(target, prop)?.writable))
+			) {
+				if (s === undefined) {
+					s = with_parent(() => source(has ? proxy(target[prop]) : UNINITIALIZED, stack));
+					sources.set(prop, s);
+				}
+
+				var value = get(s);
+				if (value === UNINITIALIZED) {
+					return false;
+				}
+			}
+
+			return has;
+		},
+
+		set(target, prop, value, receiver) {
+			var s = sources.get(prop);
+			var has = prop in target;
+
+			// variable.length = value -> clear all signals with index >= value
+			if (is_proxied_array && prop === 'length') {
+				for (var i = value; i < /** @type {Source<number>} */ (s).v; i += 1) {
+					var other_s = sources.get(i + '');
+					if (other_s !== undefined) {
+						set(other_s, UNINITIALIZED);
+					} else if (i in target) {
+						// If the item exists in the original, we need to create a uninitialized source,
+						// else a later read of the property would result in a source being created with
+						// the value of the original item at that index.
+						other_s = with_parent(() => source(UNINITIALIZED, stack));
+						sources.set(i + '', other_s);
+					}
+				}
+			}
+
+			// If we haven't yet created a source for this property, we need to ensure
+			// we do so otherwise if we read it later, then the write won't be tracked and
+			// the heuristics of effects will be different vs if we had read the proxied
+			// object property before writing to that property.
+			if (s === undefined) {
+				if (!has || get_descriptor(target, prop)?.writable) {
+					s = with_parent(() => source(undefined, stack));
+					set(
+						s,
+						with_parent(() => proxy(value))
+					);
+					sources.set(prop, s);
+				}
+			} else {
+				has = s.v !== UNINITIALIZED;
+				set(
+					s,
+					with_parent(() => proxy(value))
+				);
+			}
+
+			var descriptor = Reflect.getOwnPropertyDescriptor(target, prop);
+
+			// Set the new value before updating any signals so that any listeners get the new value
+			if (descriptor?.set) {
+				descriptor.set.call(receiver, value);
+			}
+
+			if (!has) {
+				// If we have mutated an array directly, we might need to
+				// signal that length has also changed. Do it before updating metadata
+				// to ensure that iterating over the array as a result of a metadata update
+				// will not cause the length to be out of sync.
+				if (is_proxied_array && typeof prop === 'string') {
+					var ls = /** @type {Source<number>} */ (sources.get('length'));
+					var n = Number(prop);
+
+					if (Number.isInteger(n) && n >= ls.v) {
+						set(ls, n + 1);
+					}
+				}
+
+				update_version(version);
+			}
+
+			return true;
+		},
+
+		ownKeys(target) {
+			get(version);
+
+			var own_keys = Reflect.ownKeys(target).filter((key) => {
+				var source = sources.get(key);
+				return source === undefined || source.v !== UNINITIALIZED;
+			});
+
+			for (var [key, source] of sources) {
+				if (source.v !== UNINITIALIZED && !(key in target)) {
+					own_keys.push(key);
+				}
+			}
+
+			return own_keys;
+		},
+
+		setPrototypeOf() {
+			e.state_prototype_fixed();
+		}
+	});
+}
+
+/**
+ * @param {Source<number>} signal
+ * @param {1 | -1} [d]
+ */
+function update_version(signal, d = 1) {
+	set(signal, signal.v + d);
+}
+
+/**
+ * @param {any} value
+ */
+export function get_proxied_value(value) {
+	try {
+		if (value !== null && typeof value === 'object' && STATE_SYMBOL in value) {
+			return value[STATE_SYMBOL];
+		}
+	} catch {
+		// the above if check can throw an error if the value in question
+		// is the contentWindow of an iframe on another domain, in which
+		// case we want to just return the value (because it's definitely
+		// not a proxied value) so we don't break any JavaScript interacting
+		// with that iframe (such as various payment companies client side
+		// JavaScript libraries interacting with their iframes on the same
+		// domain)
+	}
+
+	return value;
+}
+
+/**
+ * @param {any} a
+ * @param {any} b
+ */
+export function is(a, b) {
+	return Object.is(get_proxied_value(a), get_proxied_value(b));
+}

data/lib/mount_svelte/node_modules/svelte/src/internal/client/reactivity/deriveds.js

@@ -0,0 +1,184 @@
+/** @import { Derived, Effect } from '#client' */
+import { DEV } from 'esm-env';
+import { CLEAN, DERIVED, DIRTY, EFFECT_HAS_DERIVED, MAYBE_DIRTY, UNOWNED } from '../constants.js';
+import {
+	active_reaction,
+	active_effect,
+	set_signal_status,
+	skip_reaction,
+	update_reaction,
+	increment_write_version,
+	set_active_effect,
+	push_reaction_value
+} from '../runtime.js';
+import { equals, safe_equals } from './equality.js';
+import * as e from '../errors.js';
+import { destroy_effect } from './effects.js';
+import { inspect_effects, set_inspect_effects } from './sources.js';
+import { get_stack } from '../dev/tracing.js';
+import { tracing_mode_flag } from '../../flags/index.js';
+import { component_context } from '../context.js';
+
+/**
+ * @template V
+ * @param {() => V} fn
+ * @returns {Derived<V>}
+ */
+/*#__NO_SIDE_EFFECTS__*/
+export function derived(fn) {
+	var flags = DERIVED | DIRTY;
+	var parent_derived =
+		active_reaction !== null && (active_reaction.f & DERIVED) !== 0
+			? /** @type {Derived} */ (active_reaction)
+			: null;
+
+	if (active_effect === null || (parent_derived !== null && (parent_derived.f & UNOWNED) !== 0)) {
+		flags |= UNOWNED;
+	} else {
+		// Since deriveds are evaluated lazily, any effects created inside them are
+		// created too late to ensure that the parent effect is added to the tree
+		active_effect.f |= EFFECT_HAS_DERIVED;
+	}
+
+	/** @type {Derived<V>} */
+	const signal = {
+		ctx: component_context,
+		deps: null,
+		effects: null,
+		equals,
+		f: flags,
+		fn,
+		reactions: null,
+		rv: 0,
+		v: /** @type {V} */ (null),
+		wv: 0,
+		parent: parent_derived ?? active_effect
+	};
+
+	if (DEV && tracing_mode_flag) {
+		signal.created = get_stack('CreatedAt');
+	}
+
+	return signal;
+}
+
+/**
+ * @template V
+ * @param {() => V} fn
+ * @returns {Derived<V>}
+ */
+/*#__NO_SIDE_EFFECTS__*/
+export function user_derived(fn) {
+	const d = derived(fn);
+
+	push_reaction_value(d);
+
+	return d;
+}
+
+/**
+ * @template V
+ * @param {() => V} fn
+ * @returns {Derived<V>}
+ */
+/*#__NO_SIDE_EFFECTS__*/
+export function derived_safe_equal(fn) {
+	const signal = derived(fn);
+	signal.equals = safe_equals;
+	return signal;
+}
+
+/**
+ * @param {Derived} derived
+ * @returns {void}
+ */
+export function destroy_derived_effects(derived) {
+	var effects = derived.effects;
+
+	if (effects !== null) {
+		derived.effects = null;
+
+		for (var i = 0; i < effects.length; i += 1) {
+			destroy_effect(/** @type {Effect} */ (effects[i]));
+		}
+	}
+}
+
+/**
+ * The currently updating deriveds, used to detect infinite recursion
+ * in dev mode and provide a nicer error than 'too much recursion'
+ * @type {Derived[]}
+ */
+let stack = [];
+
+/**
+ * @param {Derived} derived
+ * @returns {Effect | null}
+ */
+function get_derived_parent_effect(derived) {
+	var parent = derived.parent;
+	while (parent !== null) {
+		if ((parent.f & DERIVED) === 0) {
+			return /** @type {Effect} */ (parent);
+		}
+		parent = parent.parent;
+	}
+	return null;
+}
+
+/**
+ * @template T
+ * @param {Derived} derived
+ * @returns {T}
+ */
+export function execute_derived(derived) {
+	var value;
+	var prev_active_effect = active_effect;
+
+	set_active_effect(get_derived_parent_effect(derived));
+
+	if (DEV) {
+		let prev_inspect_effects = inspect_effects;
+		set_inspect_effects(new Set());
+		try {
+			if (stack.includes(derived)) {
+				e.derived_references_self();
+			}
+
+			stack.push(derived);
+
+			destroy_derived_effects(derived);
+			value = update_reaction(derived);
+		} finally {
+			set_active_effect(prev_active_effect);
+			set_inspect_effects(prev_inspect_effects);
+			stack.pop();
+		}
+	} else {
+		try {
+			destroy_derived_effects(derived);
+			value = update_reaction(derived);
+		} finally {
+			set_active_effect(prev_active_effect);
+		}
+	}
+
+	return value;
+}
+
+/**
+ * @param {Derived} derived
+ * @returns {void}
+ */
+export function update_derived(derived) {
+	var value = execute_derived(derived);
+	var status =
+		(skip_reaction || (derived.f & UNOWNED) !== 0) && derived.deps !== null ? MAYBE_DIRTY : CLEAN;
+
+	set_signal_status(derived, status);
+
+	if (!derived.equals(value)) {
+		derived.v = value;
+		derived.wv = increment_write_version();
+	}
+}