svelte-on-rails 0.0.1

data/lib/mount_svelte/node_modules/svelte/src/internal/client/dom/legacy/event-modifiers.js

@@ -0,0 +1,128 @@
+/** @import { ActionReturn } from 'svelte/action' */
+import { noop } from '../../../shared/utils.js';
+import { user_pre_effect } from '../../reactivity/effects.js';
+import { on } from '../elements/events.js';
+
+/**
+ * Substitute for the `trusted` event modifier
+ * @deprecated
+ * @param {(event: Event, ...args: Array<unknown>) => void} fn
+ * @returns {(event: Event, ...args: unknown[]) => void}
+ */
+export function trusted(fn) {
+	return function (...args) {
+		var event = /** @type {Event} */ (args[0]);
+		if (event.isTrusted) {
+			// @ts-ignore
+			fn?.apply(this, args);
+		}
+	};
+}
+
+/**
+ * Substitute for the `self` event modifier
+ * @deprecated
+ * @param {(event: Event, ...args: Array<unknown>) => void} fn
+ * @returns {(event: Event, ...args: unknown[]) => void}
+ */
+export function self(fn) {
+	return function (...args) {
+		var event = /** @type {Event} */ (args[0]);
+		// @ts-ignore
+		if (event.target === this) {
+			// @ts-ignore
+			fn?.apply(this, args);
+		}
+	};
+}
+
+/**
+ * Substitute for the `stopPropagation` event modifier
+ * @deprecated
+ * @param {(event: Event, ...args: Array<unknown>) => void} fn
+ * @returns {(event: Event, ...args: unknown[]) => void}
+ */
+export function stopPropagation(fn) {
+	return function (...args) {
+		var event = /** @type {Event} */ (args[0]);
+		event.stopPropagation();
+		// @ts-ignore
+		return fn?.apply(this, args);
+	};
+}
+
+/**
+ * Substitute for the `once` event modifier
+ * @deprecated
+ * @param {(event: Event, ...args: Array<unknown>) => void} fn
+ * @returns {(event: Event, ...args: unknown[]) => void}
+ */
+export function once(fn) {
+	var ran = false;
+
+	return function (...args) {
+		if (ran) return;
+		ran = true;
+
+		// @ts-ignore
+		return fn?.apply(this, args);
+	};
+}
+
+/**
+ * Substitute for the `stopImmediatePropagation` event modifier
+ * @deprecated
+ * @param {(event: Event, ...args: Array<unknown>) => void} fn
+ * @returns {(event: Event, ...args: unknown[]) => void}
+ */
+export function stopImmediatePropagation(fn) {
+	return function (...args) {
+		var event = /** @type {Event} */ (args[0]);
+		event.stopImmediatePropagation();
+		// @ts-ignore
+		return fn?.apply(this, args);
+	};
+}
+
+/**
+ * Substitute for the `preventDefault` event modifier
+ * @deprecated
+ * @param {(event: Event, ...args: Array<unknown>) => void} fn
+ * @returns {(event: Event, ...args: unknown[]) => void}
+ */
+export function preventDefault(fn) {
+	return function (...args) {
+		var event = /** @type {Event} */ (args[0]);
+		event.preventDefault();
+		// @ts-ignore
+		return fn?.apply(this, args);
+	};
+}
+
+/**
+ * Substitute for the `passive` event modifier, implemented as an action
+ * @deprecated
+ * @param {HTMLElement} node
+ * @param {[event: string, handler: () => EventListener]} options
+ */
+export function passive(node, [event, handler]) {
+	user_pre_effect(() => {
+		return on(node, event, handler() ?? noop, {
+			passive: true
+		});
+	});
+}
+
+/**
+ * Substitute for the `nonpassive` event modifier, implemented as an action
+ * @deprecated
+ * @param {HTMLElement} node
+ * @param {[event: string, handler: () => EventListener]} options
+ */
+export function nonpassive(node, [event, handler]) {
+	user_pre_effect(() => {
+		return on(node, event, handler() ?? noop, {
+			passive: false
+		});
+	});
+}

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

@@ -0,0 +1,82 @@
+/** @import { ComponentContextLegacy } from '#client' */
+import { run, run_all } from '../../../shared/utils.js';
+import { component_context } from '../../context.js';
+import { derived } from '../../reactivity/deriveds.js';
+import { user_pre_effect, user_effect } from '../../reactivity/effects.js';
+import { deep_read_state, get, untrack } from '../../runtime.js';
+
+/**
+ * Legacy-mode only: Call `onMount` callbacks and set up `beforeUpdate`/`afterUpdate` effects
+ * @param {boolean} [immutable]
+ */
+export function init(immutable = false) {
+	const context = /** @type {ComponentContextLegacy} */ (component_context);
+
+	const callbacks = context.l.u;
+	if (!callbacks) return;
+
+	let props = () => deep_read_state(context.s);
+
+	if (immutable) {
+		let version = 0;
+		let prev = /** @type {Record<string, any>} */ ({});
+
+		// In legacy immutable mode, before/afterUpdate only fire if the object identity of a prop changes
+		const d = derived(() => {
+			let changed = false;
+			const props = context.s;
+			for (const key in props) {
+				if (props[key] !== prev[key]) {
+					prev[key] = props[key];
+					changed = true;
+				}
+			}
+			if (changed) version++;
+			return version;
+		});
+
+		props = () => get(d);
+	}
+
+	// beforeUpdate
+	if (callbacks.b.length) {
+		user_pre_effect(() => {
+			observe_all(context, props);
+			run_all(callbacks.b);
+		});
+	}
+
+	// onMount (must run before afterUpdate)
+	user_effect(() => {
+		const fns = untrack(() => callbacks.m.map(run));
+		return () => {
+			for (const fn of fns) {
+				if (typeof fn === 'function') {
+					fn();
+				}
+			}
+		};
+	});
+
+	// afterUpdate
+	if (callbacks.a.length) {
+		user_effect(() => {
+			observe_all(context, props);
+			run_all(callbacks.a);
+		});
+	}
+}
+
+/**
+ * Invoke the getter of all signals associated with a component
+ * so they can be registered to the effect this function is called in.
+ * @param {ComponentContextLegacy} context
+ * @param {(() => void)} props
+ */
+function observe_all(context, props) {
+	if (context.l.s) {
+		for (const signal of context.l.s) get(signal);
+	}
+
+	props();
+}

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

@@ -0,0 +1,68 @@
+import { set, source } from '../../reactivity/sources.js';
+import { get } from '../../runtime.js';
+import { is_array } from '../../../shared/utils.js';
+
+/**
+ * Under some circumstances, imports may be reactive in legacy mode. In that case,
+ * they should be using `reactive_import` as part of the transformation
+ * @param {() => any} fn
+ */
+export function reactive_import(fn) {
+	var s = source(0);
+
+	return function () {
+		if (arguments.length === 1) {
+			set(s, get(s) + 1);
+			return arguments[0];
+		} else {
+			get(s);
+			return fn();
+		}
+	};
+}
+
+/**
+ * @this {any}
+ * @param {Record<string, unknown>} $$props
+ * @param {Event} event
+ * @returns {void}
+ */
+export function bubble_event($$props, event) {
+	var events = /** @type {Record<string, Function[] | Function>} */ ($$props.$$events)?.[
+		event.type
+	];
+
+	var callbacks = is_array(events) ? events.slice() : events == null ? [] : [events];
+
+	for (var fn of callbacks) {
+		// Preserve "this" context
+		fn.call(this, event);
+	}
+}
+
+/**
+ * Used to simulate `$on` on a component instance when `compatibility.componentApi === 4`
+ * @param {Record<string, any>} $$props
+ * @param {string} event_name
+ * @param {Function} event_callback
+ */
+export function add_legacy_event_listener($$props, event_name, event_callback) {
+	$$props.$$events ||= {};
+	$$props.$$events[event_name] ||= [];
+	$$props.$$events[event_name].push(event_callback);
+}
+
+/**
+ * Used to simulate `$set` on a component instance when `compatibility.componentApi === 4`.
+ * Needs component accessors so that it can call the setter of the prop. Therefore doesn't
+ * work for updating props in `$$props` or `$$restProps`.
+ * @this {Record<string, any>}
+ * @param {Record<string, any>} $$new_props
+ */
+export function update_legacy_props($$new_props) {
+	for (var key in $$new_props) {
+		if (key in this) {
+			this[key] = $$new_props[key];
+		}
+	}
+}

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

@@ -0,0 +1,206 @@
+/** @import { TemplateNode } from '#client' */
+import { hydrate_node, hydrating, set_hydrate_node } from './hydration.js';
+import { DEV } from 'esm-env';
+import { init_array_prototype_warnings } from '../dev/equality.js';
+import { get_descriptor, is_extensible } from '../../shared/utils.js';
+
+// export these for reference in the compiled code, making global name deduplication unnecessary
+/** @type {Window} */
+export var $window;
+
+/** @type {Document} */
+export var $document;
+
+/** @type {boolean} */
+export var is_firefox;
+
+/** @type {() => Node | null} */
+var first_child_getter;
+/** @type {() => Node | null} */
+var next_sibling_getter;
+
+/**
+ * Initialize these lazily to avoid issues when using the runtime in a server context
+ * where these globals are not available while avoiding a separate server entry point
+ */
+export function init_operations() {
+	if ($window !== undefined) {
+		return;
+	}
+
+	$window = window;
+	$document = document;
+	is_firefox = /Firefox/.test(navigator.userAgent);
+
+	var element_prototype = Element.prototype;
+	var node_prototype = Node.prototype;
+	var text_prototype = Text.prototype;
+
+	// @ts-ignore
+	first_child_getter = get_descriptor(node_prototype, 'firstChild').get;
+	// @ts-ignore
+	next_sibling_getter = get_descriptor(node_prototype, 'nextSibling').get;
+
+	if (is_extensible(element_prototype)) {
+		// the following assignments improve perf of lookups on DOM nodes
+		// @ts-expect-error
+		element_prototype.__click = undefined;
+		// @ts-expect-error
+		element_prototype.__className = undefined;
+		// @ts-expect-error
+		element_prototype.__attributes = null;
+		// @ts-expect-error
+		element_prototype.__style = undefined;
+		// @ts-expect-error
+		element_prototype.__e = undefined;
+	}
+
+	if (is_extensible(text_prototype)) {
+		// @ts-expect-error
+		text_prototype.__t = undefined;
+	}
+
+	if (DEV) {
+		// @ts-expect-error
+		element_prototype.__svelte_meta = null;
+
+		init_array_prototype_warnings();
+	}
+}
+
+/**
+ * @param {string} value
+ * @returns {Text}
+ */
+export function create_text(value = '') {
+	return document.createTextNode(value);
+}
+
+/**
+ * @template {Node} N
+ * @param {N} node
+ * @returns {Node | null}
+ */
+/*@__NO_SIDE_EFFECTS__*/
+export function get_first_child(node) {
+	return first_child_getter.call(node);
+}
+
+/**
+ * @template {Node} N
+ * @param {N} node
+ * @returns {Node | null}
+ */
+/*@__NO_SIDE_EFFECTS__*/
+export function get_next_sibling(node) {
+	return next_sibling_getter.call(node);
+}
+
+/**
+ * Don't mark this as side-effect-free, hydration needs to walk all nodes
+ * @template {Node} N
+ * @param {N} node
+ * @param {boolean} is_text
+ * @returns {Node | null}
+ */
+export function child(node, is_text) {
+	if (!hydrating) {
+		return get_first_child(node);
+	}
+
+	var child = /** @type {TemplateNode} */ (get_first_child(hydrate_node));
+
+	// Child can be null if we have an element with a single child, like `<p>{text}</p>`, where `text` is empty
+	if (child === null) {
+		child = hydrate_node.appendChild(create_text());
+	} else if (is_text && child.nodeType !== 3) {
+		var text = create_text();
+		child?.before(text);
+		set_hydrate_node(text);
+		return text;
+	}
+
+	set_hydrate_node(child);
+	return child;
+}
+
+/**
+ * Don't mark this as side-effect-free, hydration needs to walk all nodes
+ * @param {DocumentFragment | TemplateNode[]} fragment
+ * @param {boolean} is_text
+ * @returns {Node | null}
+ */
+export function first_child(fragment, is_text) {
+	if (!hydrating) {
+		// when not hydrating, `fragment` is a `DocumentFragment` (the result of calling `open_frag`)
+		var first = /** @type {DocumentFragment} */ (get_first_child(/** @type {Node} */ (fragment)));
+
+		// TODO prevent user comments with the empty string when preserveComments is true
+		if (first instanceof Comment && first.data === '') return get_next_sibling(first);
+
+		return first;
+	}
+
+	// if an {expression} is empty during SSR, there might be no
+	// text node to hydrate — we must therefore create one
+	if (is_text && hydrate_node?.nodeType !== 3) {
+		var text = create_text();
+
+		hydrate_node?.before(text);
+		set_hydrate_node(text);
+		return text;
+	}
+
+	return hydrate_node;
+}
+
+/**
+ * Don't mark this as side-effect-free, hydration needs to walk all nodes
+ * @param {TemplateNode} node
+ * @param {number} count
+ * @param {boolean} is_text
+ * @returns {Node | null}
+ */
+export function sibling(node, count = 1, is_text = false) {
+	let next_sibling = hydrating ? hydrate_node : node;
+	var last_sibling;
+
+	while (count--) {
+		last_sibling = next_sibling;
+		next_sibling = /** @type {TemplateNode} */ (get_next_sibling(next_sibling));
+	}
+
+	if (!hydrating) {
+		return next_sibling;
+	}
+
+	var type = next_sibling?.nodeType;
+
+	// if a sibling {expression} is empty during SSR, there might be no
+	// text node to hydrate — we must therefore create one
+	if (is_text && type !== 3) {
+		var text = create_text();
+		// If the next sibling is `null` and we're handling text then it's because
+		// the SSR content was empty for the text, so we need to generate a new text
+		// node and insert it after the last sibling
+		if (next_sibling === null) {
+			last_sibling?.after(text);
+		} else {
+			next_sibling.before(text);
+		}
+		set_hydrate_node(text);
+		return text;
+	}
+
+	set_hydrate_node(next_sibling);
+	return /** @type {TemplateNode} */ (next_sibling);
+}
+
+/**
+ * @template {Node} N
+ * @param {N} node
+ * @returns {void}
+ */
+export function clear_text_content(node) {
+	node.textContent = '';
+}

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

@@ -0,0 +1,6 @@
+/** @param {string} html */
+export function create_fragment_from_html(html) {
+	var elem = document.createElement('template');
+	elem.innerHTML = html;
+	return elem.content;
+}

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

@@ -0,0 +1,60 @@
+import { run_all } from '../../shared/utils.js';
+
+// Fallback for when requestIdleCallback is not available
+const request_idle_callback =
+	typeof requestIdleCallback === 'undefined'
+		? (/** @type {() => void} */ cb) => setTimeout(cb, 1)
+		: requestIdleCallback;
+
+/** @type {Array<() => void>} */
+let micro_tasks = [];
+
+/** @type {Array<() => void>} */
+let idle_tasks = [];
+
+function run_micro_tasks() {
+	var tasks = micro_tasks;
+	micro_tasks = [];
+	run_all(tasks);
+}
+
+function run_idle_tasks() {
+	var tasks = idle_tasks;
+	idle_tasks = [];
+	run_all(tasks);
+}
+
+/**
+ * @param {() => void} fn
+ */
+export function queue_micro_task(fn) {
+	if (micro_tasks.length === 0) {
+		queueMicrotask(run_micro_tasks);
+	}
+
+	micro_tasks.push(fn);
+}
+
+/**
+ * @param {() => void} fn
+ */
+export function queue_idle_task(fn) {
+	if (idle_tasks.length === 0) {
+		request_idle_callback(run_idle_tasks);
+	}
+
+	idle_tasks.push(fn);
+}
+
+/**
+ * Synchronously run any queued tasks.
+ */
+export function flush_tasks() {
+	if (micro_tasks.length > 0) {
+		run_micro_tasks();
+	}
+
+	if (idle_tasks.length > 0) {
+		run_idle_tasks();
+	}
+}