svelte-on-rails 0.0.1

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

@@ -0,0 +1,214 @@
+/** @import { ComponentContext, ComponentContextLegacy } from '#client' */
+/** @import { EventDispatcher } from './index.js' */
+/** @import { NotFunction } from './internal/types.js' */
+import { untrack } from './internal/client/runtime.js';
+import { is_array } from './internal/shared/utils.js';
+import { user_effect } from './internal/client/index.js';
+import * as e from './internal/client/errors.js';
+import { lifecycle_outside_component } from './internal/shared/errors.js';
+import { legacy_mode_flag } from './internal/flags/index.js';
+import { component_context } from './internal/client/context.js';
+import { DEV } from 'esm-env';
+
+if (DEV) {
+	/**
+	 * @param {string} rune
+	 */
+	function throw_rune_error(rune) {
+		if (!(rune in globalThis)) {
+			// TODO if people start adjusting the "this can contain runes" config through v-p-s more, adjust this message
+			/** @type {any} */
+			let value; // let's hope noone modifies this global, but belts and braces
+			Object.defineProperty(globalThis, rune, {
+				configurable: true,
+				// eslint-disable-next-line getter-return
+				get: () => {
+					if (value !== undefined) {
+						return value;
+					}
+
+					e.rune_outside_svelte(rune);
+				},
+				set: (v) => {
+					value = v;
+				}
+			});
+		}
+	}
+
+	throw_rune_error('$state');
+	throw_rune_error('$effect');
+	throw_rune_error('$derived');
+	throw_rune_error('$inspect');
+	throw_rune_error('$props');
+	throw_rune_error('$bindable');
+}
+
+/**
+ * `onMount`, like [`$effect`](https://svelte.dev/docs/svelte/$effect), schedules a function to run as soon as the component has been mounted to the DOM.
+ * Unlike `$effect`, the provided function only runs once.
+ *
+ * It must be called during the component's initialisation (but doesn't need to live _inside_ the component;
+ * it can be called from an external module). If a function is returned _synchronously_ from `onMount`,
+ * it will be called when the component is unmounted.
+ *
+ * `onMount` functions do not run during [server-side rendering](https://svelte.dev/docs/svelte/svelte-server#render).
+ *
+ * @template T
+ * @param {() => NotFunction<T> | Promise<NotFunction<T>> | (() => any)} fn
+ * @returns {void}
+ */
+export function onMount(fn) {
+	if (component_context === null) {
+		lifecycle_outside_component('onMount');
+	}
+
+	if (legacy_mode_flag && component_context.l !== null) {
+		init_update_callbacks(component_context).m.push(fn);
+	} else {
+		user_effect(() => {
+			const cleanup = untrack(fn);
+			if (typeof cleanup === 'function') return /** @type {() => void} */ (cleanup);
+		});
+	}
+}
+
+/**
+ * Schedules a callback to run immediately before the component is unmounted.
+ *
+ * Out of `onMount`, `beforeUpdate`, `afterUpdate` and `onDestroy`, this is the
+ * only one that runs inside a server-side component.
+ *
+ * @param {() => any} fn
+ * @returns {void}
+ */
+export function onDestroy(fn) {
+	if (component_context === null) {
+		lifecycle_outside_component('onDestroy');
+	}
+
+	onMount(() => () => untrack(fn));
+}
+
+/**
+ * @template [T=any]
+ * @param {string} type
+ * @param {T} [detail]
+ * @param {any}params_0
+ * @returns {CustomEvent<T>}
+ */
+function create_custom_event(type, detail, { bubbles = false, cancelable = false } = {}) {
+	return new CustomEvent(type, { detail, bubbles, cancelable });
+}
+
+/**
+ * Creates an event dispatcher that can be used to dispatch [component events](https://svelte.dev/docs/svelte/legacy-on#Component-events).
+ * Event dispatchers are functions that can take two arguments: `name` and `detail`.
+ *
+ * Component events created with `createEventDispatcher` create a
+ * [CustomEvent](https://developer.mozilla.org/en-US/docs/Web/API/CustomEvent).
+ * These events do not [bubble](https://developer.mozilla.org/en-US/docs/Learn/JavaScript/Building_blocks/Events#Event_bubbling_and_capture).
+ * The `detail` argument corresponds to the [CustomEvent.detail](https://developer.mozilla.org/en-US/docs/Web/API/CustomEvent/detail)
+ * property and can contain any type of data.
+ *
+ * The event dispatcher can be typed to narrow the allowed event names and the type of the `detail` argument:
+ * ```ts
+ * const dispatch = createEventDispatcher<{
+ *  loaded: never; // does not take a detail argument
+ *  change: string; // takes a detail argument of type string, which is required
+ *  optional: number | null; // takes an optional detail argument of type number
+ * }>();
+ * ```
+ *
+ * @deprecated Use callback props and/or the `$host()` rune instead — see [migration guide](https://svelte.dev/docs/svelte/v5-migration-guide#Event-changes-Component-events)
+ * @template {Record<string, any>} [EventMap = any]
+ * @returns {EventDispatcher<EventMap>}
+ */
+export function createEventDispatcher() {
+	const active_component_context = component_context;
+	if (active_component_context === null) {
+		lifecycle_outside_component('createEventDispatcher');
+	}
+
+	return (type, detail, options) => {
+		const events = /** @type {Record<string, Function | Function[]>} */ (
+			active_component_context.s.$$events
+		)?.[/** @type {any} */ (type)];
+
+		if (events) {
+			const callbacks = is_array(events) ? events.slice() : [events];
+			// TODO are there situations where events could be dispatched
+			// in a server (non-DOM) environment?
+			const event = create_custom_event(/** @type {string} */ (type), detail, options);
+			for (const fn of callbacks) {
+				fn.call(active_component_context.x, event);
+			}
+			return !event.defaultPrevented;
+		}
+
+		return true;
+	};
+}
+
+// TODO mark beforeUpdate and afterUpdate as deprecated in Svelte 6
+
+/**
+ * Schedules a callback to run immediately before the component is updated after any state change.
+ *
+ * The first time the callback runs will be before the initial `onMount`.
+ *
+ * In runes mode use `$effect.pre` instead.
+ *
+ * @deprecated Use [`$effect.pre`](https://svelte.dev/docs/svelte/$effect#$effect.pre) instead
+ * @param {() => void} fn
+ * @returns {void}
+ */
+export function beforeUpdate(fn) {
+	if (component_context === null) {
+		lifecycle_outside_component('beforeUpdate');
+	}
+
+	if (component_context.l === null) {
+		e.lifecycle_legacy_only('beforeUpdate');
+	}
+
+	init_update_callbacks(component_context).b.push(fn);
+}
+
+/**
+ * Schedules a callback to run immediately after the component has been updated.
+ *
+ * The first time the callback runs will be after the initial `onMount`.
+ *
+ * In runes mode use `$effect` instead.
+ *
+ * @deprecated Use [`$effect`](https://svelte.dev/docs/svelte/$effect) instead
+ * @param {() => void} fn
+ * @returns {void}
+ */
+export function afterUpdate(fn) {
+	if (component_context === null) {
+		lifecycle_outside_component('afterUpdate');
+	}
+
+	if (component_context.l === null) {
+		e.lifecycle_legacy_only('afterUpdate');
+	}
+
+	init_update_callbacks(component_context).a.push(fn);
+}
+
+/**
+ * Legacy-mode: Init callbacks object for onMount/beforeUpdate/afterUpdate
+ * @param {ComponentContext} context
+ */
+function init_update_callbacks(context) {
+	var l = /** @type {ComponentContextLegacy} */ (context).l;
+	return (l.u ??= { a: [], b: [], m: [] });
+}
+
+export { flushSync } from './internal/client/runtime.js';
+export { getContext, getAllContexts, hasContext, setContext } from './internal/client/context.js';
+export { hydrate, mount, unmount } from './internal/client/render.js';
+export { tick, untrack } from './internal/client/runtime.js';
+export { createRawSnippet } from './internal/client/dom/blocks/snippet.js';

data/lib/mount_svelte/node_modules/svelte/src/index-server.js

@@ -0,0 +1,40 @@
+/** @import { Component } from '#server' */
+import { current_component } from './internal/server/context.js';
+import { noop } from './internal/shared/utils.js';
+import * as e from './internal/server/errors.js';
+
+/** @param {() => void} fn */
+export function onDestroy(fn) {
+	var context = /** @type {Component} */ (current_component);
+	(context.d ??= []).push(fn);
+}
+
+export {
+	noop as beforeUpdate,
+	noop as afterUpdate,
+	noop as onMount,
+	noop as flushSync,
+	run as untrack
+} from './internal/shared/utils.js';
+
+export function createEventDispatcher() {
+	return noop;
+}
+
+export function mount() {
+	e.lifecycle_function_unavailable('mount');
+}
+
+export function hydrate() {
+	e.lifecycle_function_unavailable('hydrate');
+}
+
+export function unmount() {
+	e.lifecycle_function_unavailable('unmount');
+}
+
+export async function tick() {}
+
+export { getAllContexts, getContext, hasContext, setContext } from './internal/server/context.js';
+
+export { createRawSnippet } from './internal/server/blocks/snippet.js';

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

@@ -0,0 +1,27 @@
+export const DERIVED = 1 << 1;
+export const EFFECT = 1 << 2;
+export const RENDER_EFFECT = 1 << 3;
+export const BLOCK_EFFECT = 1 << 4;
+export const BRANCH_EFFECT = 1 << 5;
+export const ROOT_EFFECT = 1 << 6;
+export const BOUNDARY_EFFECT = 1 << 7;
+export const UNOWNED = 1 << 8;
+export const DISCONNECTED = 1 << 9;
+export const CLEAN = 1 << 10;
+export const DIRTY = 1 << 11;
+export const MAYBE_DIRTY = 1 << 12;
+export const INERT = 1 << 13;
+export const DESTROYED = 1 << 14;
+export const EFFECT_RAN = 1 << 15;
+/** 'Transparent' effects do not create a transition boundary */
+export const EFFECT_TRANSPARENT = 1 << 16;
+/** Svelte 4 legacy mode props need to be handled with deriveds and be recognized elsewhere, hence the dedicated flag */
+export const LEGACY_DERIVED_PROP = 1 << 17;
+export const INSPECT_EFFECT = 1 << 18;
+export const HEAD_EFFECT = 1 << 19;
+export const EFFECT_HAS_DERIVED = 1 << 20;
+export const EFFECT_IS_UPDATING = 1 << 21;
+
+export const STATE_SYMBOL = Symbol('$state');
+export const LEGACY_PROPS = Symbol('legacy props');
+export const LOADING_ATTR_SYMBOL = Symbol('');

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

@@ -0,0 +1,206 @@
+/** @import { ComponentContext } from '#client' */
+
+import { DEV } from 'esm-env';
+import { lifecycle_outside_component } from '../shared/errors.js';
+import { source } from './reactivity/sources.js';
+import {
+	active_effect,
+	active_reaction,
+	set_active_effect,
+	set_active_reaction,
+	untrack
+} from './runtime.js';
+import { effect, teardown } from './reactivity/effects.js';
+import { legacy_mode_flag } from '../flags/index.js';
+
+/** @type {ComponentContext | null} */
+export let component_context = null;
+
+/** @param {ComponentContext | null} context */
+export function set_component_context(context) {
+	component_context = context;
+}
+
+/**
+ * The current component function. Different from current component context:
+ * ```html
+ * <!-- App.svelte -->
+ * <Foo>
+ *   <Bar /> <!-- context == Foo.svelte, function == App.svelte -->
+ * </Foo>
+ * ```
+ * @type {ComponentContext['function']}
+ */
+export let dev_current_component_function = null;
+
+/** @param {ComponentContext['function']} fn */
+export function set_dev_current_component_function(fn) {
+	dev_current_component_function = fn;
+}
+
+/**
+ * Retrieves the context that belongs to the closest parent component with the specified `key`.
+ * Must be called during component initialisation.
+ *
+ * @template T
+ * @param {any} key
+ * @returns {T}
+ */
+export function getContext(key) {
+	const context_map = get_or_init_context_map('getContext');
+	const result = /** @type {T} */ (context_map.get(key));
+	return result;
+}
+
+/**
+ * Associates an arbitrary `context` object with the current component and the specified `key`
+ * and returns that object. The context is then available to children of the component
+ * (including slotted content) with `getContext`.
+ *
+ * Like lifecycle functions, this must be called during component initialisation.
+ *
+ * @template T
+ * @param {any} key
+ * @param {T} context
+ * @returns {T}
+ */
+export function setContext(key, context) {
+	const context_map = get_or_init_context_map('setContext');
+	context_map.set(key, context);
+	return context;
+}
+
+/**
+ * Checks whether a given `key` has been set in the context of a parent component.
+ * Must be called during component initialisation.
+ *
+ * @param {any} key
+ * @returns {boolean}
+ */
+export function hasContext(key) {
+	const context_map = get_or_init_context_map('hasContext');
+	return context_map.has(key);
+}
+
+/**
+ * Retrieves the whole context map that belongs to the closest parent component.
+ * Must be called during component initialisation. Useful, for example, if you
+ * programmatically create a component and want to pass the existing context to it.
+ *
+ * @template {Map<any, any>} [T=Map<any, any>]
+ * @returns {T}
+ */
+export function getAllContexts() {
+	const context_map = get_or_init_context_map('getAllContexts');
+	return /** @type {T} */ (context_map);
+}
+
+/**
+ * @param {Record<string, unknown>} props
+ * @param {any} runes
+ * @param {Function} [fn]
+ * @returns {void}
+ */
+export function push(props, runes = false, fn) {
+	var ctx = (component_context = {
+		p: component_context,
+		c: null,
+		d: false,
+		e: null,
+		m: false,
+		s: props,
+		x: null,
+		l: null
+	});
+
+	if (legacy_mode_flag && !runes) {
+		component_context.l = {
+			s: null,
+			u: null,
+			r1: [],
+			r2: source(false)
+		};
+	}
+
+	teardown(() => {
+		/** @type {ComponentContext} */ (ctx).d = true;
+	});
+
+	if (DEV) {
+		// component function
+		component_context.function = fn;
+		dev_current_component_function = fn;
+	}
+}
+
+/**
+ * @template {Record<string, any>} T
+ * @param {T} [component]
+ * @returns {T}
+ */
+export function pop(component) {
+	const context_stack_item = component_context;
+	if (context_stack_item !== null) {
+		if (component !== undefined) {
+			context_stack_item.x = component;
+		}
+		const component_effects = context_stack_item.e;
+		if (component_effects !== null) {
+			var previous_effect = active_effect;
+			var previous_reaction = active_reaction;
+			context_stack_item.e = null;
+			try {
+				for (var i = 0; i < component_effects.length; i++) {
+					var component_effect = component_effects[i];
+					set_active_effect(component_effect.effect);
+					set_active_reaction(component_effect.reaction);
+					effect(component_effect.fn);
+				}
+			} finally {
+				set_active_effect(previous_effect);
+				set_active_reaction(previous_reaction);
+			}
+		}
+		component_context = context_stack_item.p;
+		if (DEV) {
+			dev_current_component_function = context_stack_item.p?.function ?? null;
+		}
+		context_stack_item.m = true;
+	}
+	// Micro-optimization: Don't set .a above to the empty object
+	// so it can be garbage-collected when the return here is unused
+	return component || /** @type {T} */ ({});
+}
+
+/** @returns {boolean} */
+export function is_runes() {
+	return !legacy_mode_flag || (component_context !== null && component_context.l === null);
+}
+
+/**
+ * @param {string} name
+ * @returns {Map<unknown, unknown>}
+ */
+function get_or_init_context_map(name) {
+	if (component_context === null) {
+		lifecycle_outside_component(name);
+	}
+
+	return (component_context.c ??= new Map(get_parent_context(component_context) || undefined));
+}
+
+/**
+ * @param {ComponentContext} component_context
+ * @returns {Map<unknown, unknown> | null}
+ */
+function get_parent_context(component_context) {
+	let parent = component_context.p;
+	while (parent !== null) {
+		const context_map = parent.c;
+		if (context_map !== null) {
+			return context_map;
+		}
+		parent = parent.p;
+	}
+	return null;
+}

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

@@ -0,0 +1,78 @@
+import { sanitize_location } from '../../../utils.js';
+import { untrack } from '../runtime.js';
+import * as w from '../warnings.js';
+
+/**
+ *
+ * @param {any} a
+ * @param {any} b
+ * @param {string} property
+ * @param {string} location
+ */
+function compare(a, b, property, location) {
+	if (a !== b) {
+		w.assignment_value_stale(property, /** @type {string} */ (sanitize_location(location)));
+	}
+
+	return a;
+}
+
+/**
+ * @param {any} object
+ * @param {string} property
+ * @param {any} value
+ * @param {string} location
+ */
+export function assign(object, property, value, location) {
+	return compare(
+		(object[property] = value),
+		untrack(() => object[property]),
+		property,
+		location
+	);
+}
+
+/**
+ * @param {any} object
+ * @param {string} property
+ * @param {any} value
+ * @param {string} location
+ */
+export function assign_and(object, property, value, location) {
+	return compare(
+		(object[property] &&= value),
+		untrack(() => object[property]),
+		property,
+		location
+	);
+}
+
+/**
+ * @param {any} object
+ * @param {string} property
+ * @param {any} value
+ * @param {string} location
+ */
+export function assign_or(object, property, value, location) {
+	return compare(
+		(object[property] ||= value),
+		untrack(() => object[property]),
+		property,
+		location
+	);
+}
+
+/**
+ * @param {any} object
+ * @param {string} property
+ * @param {any} value
+ * @param {string} location
+ */
+export function assign_nullish(object, property, value, location) {
+	return compare(
+		(object[property] ??= value),
+		untrack(() => object[property]),
+		property,
+		location
+	);
+}

data/lib/mount_svelte/node_modules/svelte/src/internal/client/dev/console-log.js

@@ -0,0 +1,35 @@
+import { STATE_SYMBOL } from '../constants.js';
+import { snapshot } from '../../shared/clone.js';
+import * as w from '../warnings.js';
+import { untrack } from '../runtime.js';
+
+/**
+ * @param {string} method
+ * @param  {...any} objects
+ */
+export function log_if_contains_state(method, ...objects) {
+	untrack(() => {
+		try {
+			let has_state = false;
+			const transformed = [];
+
+			for (const obj of objects) {
+				if (obj && typeof obj === 'object' && STATE_SYMBOL in obj) {
+					transformed.push(snapshot(obj, true));
+					has_state = true;
+				} else {
+					transformed.push(obj);
+				}
+			}
+
+			if (has_state) {
+				w.console_log_state(method);
+
+				// eslint-disable-next-line no-console
+				console.log('%c[snapshot]', 'color: grey', ...transformed);
+			}
+		} catch {}
+	});
+
+	return objects;
+}

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

@@ -0,0 +1,31 @@
+/** @type {Map<String, Set<HTMLStyleElement>>} */
+var all_styles = new Map();
+
+/**
+ * @param {String} hash
+ * @param {HTMLStyleElement} style
+ */
+export function register_style(hash, style) {
+	var styles = all_styles.get(hash);
+
+	if (!styles) {
+		styles = new Set();
+		all_styles.set(hash, styles);
+	}
+
+	styles.add(style);
+}
+
+/**
+ * @param {String} hash
+ */
+export function cleanup_styles(hash) {
+	var styles = all_styles.get(hash);
+	if (!styles) return;
+
+	for (const style of styles) {
+		style.remove();
+	}
+
+	all_styles.delete(hash);
+}

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

@@ -0,0 +1,60 @@
+/** @import { SourceLocation } from '#shared' */
+import { HYDRATION_END, HYDRATION_START, HYDRATION_START_ELSE } from '../../../constants.js';
+import { hydrating } from '../dom/hydration.js';
+
+/**
+ * @param {any} fn
+ * @param {string} filename
+ * @param {SourceLocation[]} locations
+ * @returns {any}
+ */
+export function add_locations(fn, filename, locations) {
+	return (/** @type {any[]} */ ...args) => {
+		const dom = fn(...args);
+
+		var node = hydrating ? dom : dom.nodeType === 11 ? dom.firstChild : dom;
+		assign_locations(node, filename, locations);
+
+		return dom;
+	};
+}
+
+/**
+ * @param {Element} element
+ * @param {string} filename
+ * @param {SourceLocation} location
+ */
+function assign_location(element, filename, location) {
+	// @ts-expect-error
+	element.__svelte_meta = {
+		loc: { file: filename, line: location[0], column: location[1] }
+	};
+
+	if (location[2]) {
+		assign_locations(element.firstChild, filename, location[2]);
+	}
+}
+
+/**
+ * @param {Node | null} node
+ * @param {string} filename
+ * @param {SourceLocation[]} locations
+ */
+function assign_locations(node, filename, locations) {
+	var i = 0;
+	var depth = 0;
+
+	while (node && i < locations.length) {
+		if (hydrating && node.nodeType === 8) {
+			var comment = /** @type {Comment} */ (node);
+			if (comment.data === HYDRATION_START || comment.data === HYDRATION_START_ELSE) depth += 1;
+			else if (comment.data[0] === HYDRATION_END) depth -= 1;
+		}
+
+		if (depth === 0 && node.nodeType === 1) {
+			assign_location(/** @type {Element} */ (node), filename, locations[i++]);
+		}
+
+		node = node.nextSibling;
+	}
+}