svelte-on-rails 0.0.1

data/lib/mount_svelte/node_modules/svelte/src/internal/client/dev/equality.js

@@ -0,0 +1,101 @@
+import * as w from '../warnings.js';
+import { get_proxied_value } from '../proxy.js';
+
+export function init_array_prototype_warnings() {
+	const array_prototype = Array.prototype;
+	// The REPL ends up here over and over, and this prevents it from adding more and more patches
+	// of the same kind to the prototype, which would slow down everything over time.
+	// @ts-expect-error
+	const cleanup = Array.__svelte_cleanup;
+	if (cleanup) {
+		cleanup();
+	}
+
+	const { indexOf, lastIndexOf, includes } = array_prototype;
+
+	array_prototype.indexOf = function (item, from_index) {
+		const index = indexOf.call(this, item, from_index);
+
+		if (index === -1) {
+			for (let i = from_index ?? 0; i < this.length; i += 1) {
+				if (get_proxied_value(this[i]) === item) {
+					w.state_proxy_equality_mismatch('array.indexOf(...)');
+					break;
+				}
+			}
+		}
+
+		return index;
+	};
+
+	array_prototype.lastIndexOf = function (item, from_index) {
+		// we need to specify this.length - 1 because it's probably using something like
+		// `arguments` inside so passing undefined is different from not passing anything
+		const index = lastIndexOf.call(this, item, from_index ?? this.length - 1);
+
+		if (index === -1) {
+			for (let i = 0; i <= (from_index ?? this.length - 1); i += 1) {
+				if (get_proxied_value(this[i]) === item) {
+					w.state_proxy_equality_mismatch('array.lastIndexOf(...)');
+					break;
+				}
+			}
+		}
+
+		return index;
+	};
+
+	array_prototype.includes = function (item, from_index) {
+		const has = includes.call(this, item, from_index);
+
+		if (!has) {
+			for (let i = 0; i < this.length; i += 1) {
+				if (get_proxied_value(this[i]) === item) {
+					w.state_proxy_equality_mismatch('array.includes(...)');
+					break;
+				}
+			}
+		}
+
+		return has;
+	};
+
+	// @ts-expect-error
+	Array.__svelte_cleanup = () => {
+		array_prototype.indexOf = indexOf;
+		array_prototype.lastIndexOf = lastIndexOf;
+		array_prototype.includes = includes;
+	};
+}
+
+/**
+ * @param {any} a
+ * @param {any} b
+ * @param {boolean} equal
+ * @returns {boolean}
+ */
+export function strict_equals(a, b, equal = true) {
+	// try-catch needed because this tries to read properties of `a` and `b`,
+	// which could be disallowed for example in a secure context
+	try {
+		if ((a === b) !== (get_proxied_value(a) === get_proxied_value(b))) {
+			w.state_proxy_equality_mismatch(equal ? '===' : '!==');
+		}
+	} catch {}
+
+	return (a === b) === equal;
+}
+
+/**
+ * @param {any} a
+ * @param {any} b
+ * @param {boolean} equal
+ * @returns {boolean}
+ */
+export function equals(a, b, equal = true) {
+	if ((a == b) !== (get_proxied_value(a) == get_proxied_value(b))) {
+		w.state_proxy_equality_mismatch(equal ? '==' : '!=');
+	}
+
+	return (a == b) === equal;
+}

data/lib/mount_svelte/node_modules/svelte/src/internal/client/dev/hmr.js

@@ -0,0 +1,78 @@
+/** @import { Source, Effect, TemplateNode } from '#client' */
+import { FILENAME, HMR } from '../../../constants.js';
+import { EFFECT_TRANSPARENT } from '../constants.js';
+import { hydrate_node, hydrating } from '../dom/hydration.js';
+import { block, branch, destroy_effect } from '../reactivity/effects.js';
+import { source } from '../reactivity/sources.js';
+import { set_should_intro } from '../render.js';
+import { get } from '../runtime.js';
+
+/**
+ * @template {(anchor: Comment, props: any) => any} Component
+ * @param {Component} original
+ * @param {() => Source<Component>} get_source
+ */
+export function hmr(original, get_source) {
+	/**
+	 * @param {TemplateNode} anchor
+	 * @param {any} props
+	 */
+	function wrapper(anchor, props) {
+		let instance = {};
+
+		/** @type {Effect} */
+		let effect;
+
+		let ran = false;
+
+		block(() => {
+			const source = get_source();
+			const component = get(source);
+
+			if (effect) {
+				// @ts-ignore
+				for (var k in instance) delete instance[k];
+				destroy_effect(effect);
+			}
+
+			effect = branch(() => {
+				// when the component is invalidated, replace it without transitions
+				if (ran) set_should_intro(false);
+
+				// preserve getters/setters
+				Object.defineProperties(
+					instance,
+					Object.getOwnPropertyDescriptors(
+						// @ts-expect-error
+						new.target ? new component(anchor, props) : component(anchor, props)
+					)
+				);
+
+				if (ran) set_should_intro(true);
+			});
+		}, EFFECT_TRANSPARENT);
+
+		ran = true;
+
+		if (hydrating) {
+			anchor = hydrate_node;
+		}
+
+		return instance;
+	}
+
+	// @ts-expect-error
+	wrapper[FILENAME] = original[FILENAME];
+
+	// @ts-expect-error
+	wrapper[HMR] = {
+		// When we accept an update, we set the original source to the new component
+		original,
+		// The `get_source` parameter reads `wrapper[HMR].source`, but in the `accept`
+		// function we always replace it with `previous[HMR].source`, which in practice
+		// means we only ever update the original
+		source: source(original)
+	};
+
+	return wrapper;
+}

data/lib/mount_svelte/node_modules/svelte/src/internal/client/dev/inspect.js

@@ -0,0 +1,36 @@
+import { UNINITIALIZED } from '../../../constants.js';
+import { snapshot } from '../../shared/clone.js';
+import { inspect_effect, validate_effect } from '../reactivity/effects.js';
+
+/**
+ * @param {() => any[]} get_value
+ * @param {Function} [inspector]
+ */
+// eslint-disable-next-line no-console
+export function inspect(get_value, inspector = console.log) {
+	validate_effect('$inspect');
+
+	let initial = true;
+
+	inspect_effect(() => {
+		/** @type {any} */
+		var value = UNINITIALIZED;
+
+		// Capturing the value might result in an exception due to the inspect effect being
+		// sync and thus operating on stale data. In the case we encounter an exception we
+		// can bail-out of reporting the value. Instead we simply console.error the error
+		// so at least it's known that an error occured, but we don't stop execution
+		try {
+			value = get_value();
+		} catch (error) {
+			// eslint-disable-next-line no-console
+			console.error(error);
+		}
+
+		if (value !== UNINITIALIZED) {
+			inspector(initial ? 'init' : 'update', ...snapshot(value, true));
+		}
+
+		initial = false;
+	});
+}

data/lib/mount_svelte/node_modules/svelte/src/internal/client/dev/legacy.js

@@ -0,0 +1,25 @@
+import * as e from '../errors.js';
+import { component_context } from '../context.js';
+import { FILENAME } from '../../../constants.js';
+
+/** @param {Function & { [FILENAME]: string }} target */
+export function check_target(target) {
+	if (target) {
+		e.component_api_invalid_new(target[FILENAME] ?? 'a component', target.name);
+	}
+}
+
+export function legacy_api() {
+	const component = component_context?.function;
+
+	/** @param {string} method */
+	function error(method) {
+		e.component_api_changed(method, component[FILENAME]);
+	}
+
+	return {
+		$destroy: () => error('$destroy()'),
+		$on: () => error('$on(...)'),
+		$set: () => error('$set(...)')
+	};
+}

data/lib/mount_svelte/node_modules/svelte/src/internal/client/dev/ownership.js

@@ -0,0 +1,80 @@
+/** @typedef {{ file: string, line: number, column: number }} Location */
+
+import { get_descriptor } from '../../shared/utils.js';
+import { LEGACY_PROPS, STATE_SYMBOL } from '../constants.js';
+import { FILENAME } from '../../../constants.js';
+import { component_context } from '../context.js';
+import * as w from '../warnings.js';
+import { sanitize_location } from '../../../utils.js';
+
+/**
+ * Sets up a validator that
+ * - traverses the path of a prop to find out if it is allowed to be mutated
+ * - checks that the binding chain is not interrupted
+ * @param {Record<string, any>} props
+ */
+export function create_ownership_validator(props) {
+	const component = component_context?.function;
+	const parent = component_context?.p?.function;
+
+	return {
+		/**
+		 * @param {string} prop
+		 * @param {any[]} path
+		 * @param {any} result
+		 * @param {number} line
+		 * @param {number} column
+		 */
+		mutation: (prop, path, result, line, column) => {
+			const name = path[0];
+			if (is_bound_or_unset(props, name) || !parent) {
+				return result;
+			}
+
+			let value = props[name];
+
+			for (let i = 1; i < path.length - 1; i++) {
+				if (!value?.[STATE_SYMBOL]) {
+					return result;
+				}
+				value = value[path[i]];
+			}
+
+			const location = sanitize_location(`${component[FILENAME]}:${line}:${column}`);
+
+			w.ownership_invalid_mutation(name, location, prop, parent[FILENAME]);
+
+			return result;
+		},
+		/**
+		 * @param {any} key
+		 * @param {any} child_component
+		 * @param {() => any} value
+		 */
+		binding: (key, child_component, value) => {
+			if (!is_bound_or_unset(props, key) && parent && value()?.[STATE_SYMBOL]) {
+				w.ownership_invalid_binding(
+					component[FILENAME],
+					key,
+					child_component[FILENAME],
+					parent[FILENAME]
+				);
+			}
+		}
+	};
+}
+
+/**
+ * @param {Record<string, any>} props
+ * @param {string} prop_name
+ */
+function is_bound_or_unset(props, prop_name) {
+	// Can be the case when someone does `mount(Component, props)` with `let props = $state({...})`
+	// or `createClassComponent(Component, props)`
+	const is_entry_props = STATE_SYMBOL in props || LEGACY_PROPS in props;
+	return (
+		!!get_descriptor(props, prop_name)?.set ||
+		(is_entry_props && prop_name in props) ||
+		!(prop_name in props)
+	);
+}

data/lib/mount_svelte/node_modules/svelte/src/internal/client/dev/tracing.js

@@ -0,0 +1,179 @@
+/** @import { Derived, Reaction, Signal, Value } from '#client' */
+import { UNINITIALIZED } from '../../../constants.js';
+import { snapshot } from '../../shared/clone.js';
+import { define_property } from '../../shared/utils.js';
+import { DERIVED, STATE_SYMBOL } from '../constants.js';
+import { effect_tracking } from '../reactivity/effects.js';
+import { active_reaction, captured_signals, set_captured_signals, untrack } from '../runtime.js';
+
+/** @type { any } */
+export let tracing_expressions = null;
+
+/**
+ * @param { Value } signal
+ * @param { { read: Error[] } } [entry]
+ */
+function log_entry(signal, entry) {
+	const debug = signal.debug;
+	const value = signal.trace_need_increase ? signal.trace_v : signal.v;
+
+	if (value === UNINITIALIZED) {
+		return;
+	}
+
+	if (debug) {
+		var previous_captured_signals = captured_signals;
+		var captured = new Set();
+		set_captured_signals(captured);
+		try {
+			untrack(() => {
+				debug();
+			});
+		} finally {
+			set_captured_signals(previous_captured_signals);
+		}
+		if (captured.size > 0) {
+			for (const dep of captured) {
+				log_entry(dep);
+			}
+			return;
+		}
+	}
+
+	const type = (signal.f & DERIVED) !== 0 ? '$derived' : '$state';
+	const current_reaction = /** @type {Reaction} */ (active_reaction);
+	const dirty = signal.wv > current_reaction.wv || current_reaction.wv === 0;
+
+	// eslint-disable-next-line no-console
+	console.groupCollapsed(
+		`%c${type}`,
+		dirty ? 'color: CornflowerBlue; font-weight: bold' : 'color: grey; font-weight: bold',
+		typeof value === 'object' && value !== null && STATE_SYMBOL in value
+			? snapshot(value, true)
+			: value
+	);
+
+	if (type === '$derived') {
+		const deps = new Set(/** @type {Derived} */ (signal).deps);
+		for (const dep of deps) {
+			log_entry(dep);
+		}
+	}
+
+	if (signal.created) {
+		// eslint-disable-next-line no-console
+		console.log(signal.created);
+	}
+
+	if (signal.updated) {
+		// eslint-disable-next-line no-console
+		console.log(signal.updated);
+	}
+
+	const read = entry?.read;
+
+	if (read && read.length > 0) {
+		for (var stack of read) {
+			// eslint-disable-next-line no-console
+			console.log(stack);
+		}
+	}
+
+	// eslint-disable-next-line no-console
+	console.groupEnd();
+}
+
+/**
+ * @template T
+ * @param {() => string} label
+ * @param {() => T} fn
+ */
+export function trace(label, fn) {
+	var previously_tracing_expressions = tracing_expressions;
+	try {
+		tracing_expressions = { entries: new Map(), reaction: active_reaction };
+
+		var start = performance.now();
+		var value = fn();
+		var time = (performance.now() - start).toFixed(2);
+
+		if (!effect_tracking()) {
+			// eslint-disable-next-line no-console
+			console.log(`${label()} %cran outside of an effect (${time}ms)`, 'color: grey');
+		} else if (tracing_expressions.entries.size === 0) {
+			// eslint-disable-next-line no-console
+			console.log(`${label()} %cno reactive dependencies (${time}ms)`, 'color: grey');
+		} else {
+			// eslint-disable-next-line no-console
+			console.group(`${label()} %c(${time}ms)`, 'color: grey');
+
+			var entries = tracing_expressions.entries;
+
+			tracing_expressions = null;
+
+			for (const [signal, entry] of entries) {
+				log_entry(signal, entry);
+			}
+			// eslint-disable-next-line no-console
+			console.groupEnd();
+		}
+
+		if (previously_tracing_expressions !== null && tracing_expressions !== null) {
+			for (const [signal, entry] of tracing_expressions.entries) {
+				var prev_entry = previously_tracing_expressions.get(signal);
+
+				if (prev_entry === undefined) {
+					previously_tracing_expressions.set(signal, entry);
+				} else {
+					prev_entry.read.push(...entry.read);
+				}
+			}
+		}
+
+		return value;
+	} finally {
+		tracing_expressions = previously_tracing_expressions;
+	}
+}
+
+/**
+ * @param {string} label
+ */
+export function get_stack(label) {
+	let error = Error();
+	const stack = error.stack;
+
+	if (stack) {
+		const lines = stack.split('\n');
+		const new_lines = ['\n'];
+
+		for (let i = 0; i < lines.length; i++) {
+			const line = lines[i];
+
+			if (line === 'Error') {
+				continue;
+			}
+			if (line.includes('validate_each_keys')) {
+				return null;
+			}
+			if (line.includes('svelte/src/internal')) {
+				continue;
+			}
+			new_lines.push(line);
+		}
+
+		if (new_lines.length === 1) {
+			return null;
+		}
+
+		define_property(error, 'stack', {
+			value: new_lines.join('\n')
+		});
+
+		define_property(error, 'name', {
+			// 'Error' suffix is required for stack traces to be rendered properly
+			value: `${label}Error`
+		});
+	}
+	return error;
+}

data/lib/mount_svelte/node_modules/svelte/src/internal/client/dev/validation.js

@@ -0,0 +1,15 @@
+import { invalid_snippet_arguments } from '../../shared/errors.js';
+/**
+ * @param {Node} anchor
+ * @param {...(()=>any)[]} args
+ */
+export function validate_snippet_args(anchor, ...args) {
+	if (typeof anchor !== 'object' || !(anchor instanceof Node)) {
+		invalid_snippet_arguments();
+	}
+	for (let arg of args) {
+		if (typeof arg !== 'function') {
+			invalid_snippet_arguments();
+		}
+	}
+}

data/lib/mount_svelte/node_modules/svelte/src/internal/client/dom/blocks/await.js

@@ -0,0 +1,190 @@
+/** @import { Effect, Source, TemplateNode } from '#client' */
+import { DEV } from 'esm-env';
+import { is_promise } from '../../../shared/utils.js';
+import { block, branch, pause_effect, resume_effect } from '../../reactivity/effects.js';
+import { internal_set, mutable_source, source } from '../../reactivity/sources.js';
+import { flushSync, set_active_effect, set_active_reaction } from '../../runtime.js';
+import {
+	hydrate_next,
+	hydrate_node,
+	hydrating,
+	remove_nodes,
+	set_hydrate_node,
+	set_hydrating
+} from '../hydration.js';
+import { queue_micro_task } from '../task.js';
+import { HYDRATION_START_ELSE, UNINITIALIZED } from '../../../../constants.js';
+import {
+	component_context,
+	is_runes,
+	set_component_context,
+	set_dev_current_component_function
+} from '../../context.js';
+
+const PENDING = 0;
+const THEN = 1;
+const CATCH = 2;
+
+/**
+ * @template V
+ * @param {TemplateNode} node
+ * @param {(() => Promise<V>)} get_input
+ * @param {null | ((anchor: Node) => void)} pending_fn
+ * @param {null | ((anchor: Node, value: Source<V>) => void)} then_fn
+ * @param {null | ((anchor: Node, error: unknown) => void)} catch_fn
+ * @returns {void}
+ */
+export function await_block(node, get_input, pending_fn, then_fn, catch_fn) {
+	if (hydrating) {
+		hydrate_next();
+	}
+
+	var anchor = node;
+	var runes = is_runes();
+	var active_component_context = component_context;
+
+	/** @type {any} */
+	var component_function = DEV ? component_context?.function : null;
+
+	/** @type {V | Promise<V> | typeof UNINITIALIZED} */
+	var input = UNINITIALIZED;
+
+	/** @type {Effect | null} */
+	var pending_effect;
+
+	/** @type {Effect | null} */
+	var then_effect;
+
+	/** @type {Effect | null} */
+	var catch_effect;
+
+	var input_source = (runes ? source : mutable_source)(/** @type {V} */ (undefined));
+	var error_source = (runes ? source : mutable_source)(undefined);
+	var resolved = false;
+
+	/**
+	 * @param {PENDING | THEN | CATCH} state
+	 * @param {boolean} restore
+	 */
+	function update(state, restore) {
+		resolved = true;
+
+		if (restore) {
+			set_active_effect(effect);
+			set_active_reaction(effect); // TODO do we need both?
+			set_component_context(active_component_context);
+			if (DEV) set_dev_current_component_function(component_function);
+		}
+
+		try {
+			if (state === PENDING && pending_fn) {
+				if (pending_effect) resume_effect(pending_effect);
+				else pending_effect = branch(() => pending_fn(anchor));
+			}
+
+			if (state === THEN && then_fn) {
+				if (then_effect) resume_effect(then_effect);
+				else then_effect = branch(() => then_fn(anchor, input_source));
+			}
+
+			if (state === CATCH && catch_fn) {
+				if (catch_effect) resume_effect(catch_effect);
+				else catch_effect = branch(() => catch_fn(anchor, error_source));
+			}
+
+			if (state !== PENDING && pending_effect) {
+				pause_effect(pending_effect, () => (pending_effect = null));
+			}
+
+			if (state !== THEN && then_effect) {
+				pause_effect(then_effect, () => (then_effect = null));
+			}
+
+			if (state !== CATCH && catch_effect) {
+				pause_effect(catch_effect, () => (catch_effect = null));
+			}
+		} finally {
+			if (restore) {
+				if (DEV) set_dev_current_component_function(null);
+				set_component_context(null);
+				set_active_reaction(null);
+				set_active_effect(null);
+
+				// without this, the DOM does not update until two ticks after the promise
+				// resolves, which is unexpected behaviour (and somewhat irksome to test)
+				flushSync();
+			}
+		}
+	}
+
+	var effect = block(() => {
+		if (input === (input = get_input())) return;
+
+		/** Whether or not there was a hydration mismatch. Needs to be a `let` or else it isn't treeshaken out */
+		// @ts-ignore coercing `anchor` to a `Comment` causes TypeScript and Prettier to fight
+		let mismatch = hydrating && is_promise(input) === (anchor.data === HYDRATION_START_ELSE);
+
+		if (mismatch) {
+			// Hydration mismatch: remove everything inside the anchor and start fresh
+			anchor = remove_nodes();
+
+			set_hydrate_node(anchor);
+			set_hydrating(false);
+			mismatch = true;
+		}
+
+		if (is_promise(input)) {
+			var promise = input;
+
+			resolved = false;
+
+			promise.then(
+				(value) => {
+					if (promise !== input) return;
+					// we technically could use `set` here since it's on the next microtick
+					// but let's use internal_set for consistency and just to be safe
+					internal_set(input_source, value);
+					update(THEN, true);
+				},
+				(error) => {
+					if (promise !== input) return;
+					// we technically could use `set` here since it's on the next microtick
+					// but let's use internal_set for consistency and just to be safe
+					internal_set(error_source, error);
+					update(CATCH, true);
+					if (!catch_fn) {
+						// Rethrow the error if no catch block exists
+						throw error_source.v;
+					}
+				}
+			);
+
+			if (hydrating) {
+				if (pending_fn) {
+					pending_effect = branch(() => pending_fn(anchor));
+				}
+			} else {
+				// Wait a microtask before checking if we should show the pending state as
+				// the promise might have resolved by the next microtask.
+				queue_micro_task(() => {
+					if (!resolved) update(PENDING, true);
+				});
+			}
+		} else {
+			internal_set(input_source, input);
+			update(THEN, false);
+		}
+
+		if (mismatch) {
+			// continue in hydration mode
+			set_hydrating(true);
+		}
+
+		// Set the input to something else, in order to disable the promise callbacks
+		return () => (input = UNINITIALIZED);
+	});
+
+	if (hydrating) {
+		anchor = hydrate_node;
+	}
+}