svelte-on-rails 0.0.29 → 0.0.31

data/lib/svelte_on_rails/node_modules/svelte/src/store/index-server.js

@@ -1,101 +0,0 @@
-/** @import { Readable, Writable } from './public.js' */
-import { get, writable } from './shared/index.js';
-
-export { derived, get, readable, readonly, writable } from './shared/index.js';
-
-/**
- * @template V
- * @overload
- * @param {() => V} get
- * @param {(v: V) => void} set
- * @returns {Writable<V>}
- */
-/**
- * @template V
- * @overload
- * @param {() => V} get
- * @returns {Readable<V>}
- */
-/**
- * Create a store from a function that returns state, and (to make a writable store), an
- * optional second function that sets state.
- *
- * ```ts
- * import { toStore } from 'svelte/store';
- *
- * let count = $state(0);
- *
- * const store = toStore(() => count, (v) => (count = v));
- * ```
- * @template V
- * @param {() => V} get
- * @param {(v: V) => void} [set]
- * @returns {Writable<V> | Readable<V>}
- */
-export function toStore(get, set) {
-	const store = writable(get());
-
-	if (set) {
-		return {
-			set,
-			update: (fn) => set(fn(get())),
-			subscribe: store.subscribe
-		};
-	}
-
-	return {
-		subscribe: store.subscribe
-	};
-}
-
-/**
- * @template V
- * @overload
- * @param {Writable<V>} store
- * @returns {{ current: V }}
- */
-/**
- * @template V
- * @overload
- * @param {Readable<V>} store
- * @returns {{ readonly current: V }}
- */
-/**
- * Convert a store to an object with a reactive `current` property. If `store`
- * is a readable store, `current` will be a readonly property.
- *
- * ```ts
- * import { fromStore, get, writable } from 'svelte/store';
- *
- * const store = writable(0);
- *
- * const count = fromStore(store);
- *
- * count.current; // 0;
- * store.set(1);
- * count.current; // 1
- *
- * count.current += 1;
- * get(store); // 2
- * ```
- * @template V
- * @param {Writable<V> | Readable<V>} store
- */
-export function fromStore(store) {
-	if ('set' in store) {
-		return {
-			get current() {
-				return get(store);
-			},
-			set current(v) {
-				store.set(v);
-			}
-		};
-	}
-
-	return {
-		get current() {
-			return get(store);
-		}
-	};
-}

data/lib/svelte_on_rails/node_modules/svelte/src/store/shared/index.js

@@ -1,209 +0,0 @@
-/** @import { Readable, StartStopNotifier, Subscriber, Unsubscriber, Updater, Writable } from '../public.js' */
-/** @import { Stores, StoresValues, SubscribeInvalidateTuple } from '../private.js' */
-import { noop, run_all } from '../../internal/shared/utils.js';
-import { safe_not_equal } from '../../internal/client/reactivity/equality.js';
-import { subscribe_to_store } from '../utils.js';
-
-/**
- * @type {Array<SubscribeInvalidateTuple<any> | any>}
- */
-const subscriber_queue = [];
-
-/**
- * Creates a `Readable` store that allows reading by subscription.
- *
- * @template T
- * @param {T} [value] initial value
- * @param {StartStopNotifier<T>} [start]
- * @returns {Readable<T>}
- */
-export function readable(value, start) {
-	return {
-		subscribe: writable(value, start).subscribe
-	};
-}
-
-/**
- * Create a `Writable` store that allows both updating and reading by subscription.
- *
- * @template T
- * @param {T} [value] initial value
- * @param {StartStopNotifier<T>} [start]
- * @returns {Writable<T>}
- */
-export function writable(value, start = noop) {
-	/** @type {Unsubscriber | null} */
-	let stop = null;
-
-	/** @type {Set<SubscribeInvalidateTuple<T>>} */
-	const subscribers = new Set();
-
-	/**
-	 * @param {T} new_value
-	 * @returns {void}
-	 */
-	function set(new_value) {
-		if (safe_not_equal(value, new_value)) {
-			value = new_value;
-			if (stop) {
-				// store is ready
-				const run_queue = !subscriber_queue.length;
-				for (const subscriber of subscribers) {
-					subscriber[1]();
-					subscriber_queue.push(subscriber, value);
-				}
-				if (run_queue) {
-					for (let i = 0; i < subscriber_queue.length; i += 2) {
-						subscriber_queue[i][0](subscriber_queue[i + 1]);
-					}
-					subscriber_queue.length = 0;
-				}
-			}
-		}
-	}
-
-	/**
-	 * @param {Updater<T>} fn
-	 * @returns {void}
-	 */
-	function update(fn) {
-		set(fn(/** @type {T} */ (value)));
-	}
-
-	/**
-	 * @param {Subscriber<T>} run
-	 * @param {() => void} [invalidate]
-	 * @returns {Unsubscriber}
-	 */
-	function subscribe(run, invalidate = noop) {
-		/** @type {SubscribeInvalidateTuple<T>} */
-		const subscriber = [run, invalidate];
-		subscribers.add(subscriber);
-		if (subscribers.size === 1) {
-			stop = start(set, update) || noop;
-		}
-		run(/** @type {T} */ (value));
-		return () => {
-			subscribers.delete(subscriber);
-			if (subscribers.size === 0 && stop) {
-				stop();
-				stop = null;
-			}
-		};
-	}
-	return { set, update, subscribe };
-}
-
-/**
- * Derived value store by synchronizing one or more readable stores and
- * applying an aggregation function over its input values.
- *
- * @template {Stores} S
- * @template T
- * @overload
- * @param {S} stores
- * @param {(values: StoresValues<S>, set: (value: T) => void, update: (fn: Updater<T>) => void) => Unsubscriber | void} fn
- * @param {T} [initial_value]
- * @returns {Readable<T>}
- */
-/**
- * Derived value store by synchronizing one or more readable stores and
- * applying an aggregation function over its input values.
- *
- * @template {Stores} S
- * @template T
- * @overload
- * @param {S} stores
- * @param {(values: StoresValues<S>) => T} fn
- * @param {T} [initial_value]
- * @returns {Readable<T>}
- */
-/**
- * @template {Stores} S
- * @template T
- * @param {S} stores
- * @param {Function} fn
- * @param {T} [initial_value]
- * @returns {Readable<T>}
- */
-export function derived(stores, fn, initial_value) {
-	const single = !Array.isArray(stores);
-	/** @type {Array<Readable<any>>} */
-	const stores_array = single ? [stores] : stores;
-	if (!stores_array.every(Boolean)) {
-		throw new Error('derived() expects stores as input, got a falsy value');
-	}
-	const auto = fn.length < 2;
-	return readable(initial_value, (set, update) => {
-		let started = false;
-		/** @type {T[]} */
-		const values = [];
-		let pending = 0;
-		let cleanup = noop;
-		const sync = () => {
-			if (pending) {
-				return;
-			}
-			cleanup();
-			const result = fn(single ? values[0] : values, set, update);
-			if (auto) {
-				set(result);
-			} else {
-				cleanup = typeof result === 'function' ? result : noop;
-			}
-		};
-		const unsubscribers = stores_array.map((store, i) =>
-			subscribe_to_store(
-				store,
-				(value) => {
-					values[i] = value;
-					pending &= ~(1 << i);
-					if (started) {
-						sync();
-					}
-				},
-				() => {
-					pending |= 1 << i;
-				}
-			)
-		);
-		started = true;
-		sync();
-		return function stop() {
-			run_all(unsubscribers);
-			cleanup();
-			// We need to set this to false because callbacks can still happen despite having unsubscribed:
-			// Callbacks might already be placed in the queue which doesn't know it should no longer
-			// invoke this derived store.
-			started = false;
-		};
-	});
-}
-
-/**
- * Takes a store and returns a new one derived from the old one that is readable.
- *
- * @template T
- * @param {Readable<T>} store  - store to make readonly
- * @returns {Readable<T>}
- */
-export function readonly(store) {
-	return {
-		// @ts-expect-error TODO i suspect the bind is unnecessary
-		subscribe: store.subscribe.bind(store)
-	};
-}
-
-/**
- * Get the current value from a store by subscribing and immediately unsubscribing.
- *
- * @template T
- * @param {Readable<T>} store
- * @returns {T}
- */
-export function get(store) {
-	let value;
-	subscribe_to_store(store, (_) => (value = _))();
-	// @ts-expect-error
-	return value;
-}

data/lib/svelte_on_rails/node_modules/svelte/src/store/utils.js

@@ -1,36 +0,0 @@
-/** @import { Readable } from './public' */
-import { untrack } from '../index-client.js';
-import { noop } from '../internal/shared/utils.js';
-
-/**
- * @template T
- * @param {Readable<T> | null | undefined} store
- * @param {(value: T) => void} run
- * @param {(value: T) => void} [invalidate]
- * @returns {() => void}
- */
-export function subscribe_to_store(store, run, invalidate) {
-	if (store == null) {
-		// @ts-expect-error
-		run(undefined);
-
-		// @ts-expect-error
-		if (invalidate) invalidate(undefined);
-
-		return noop;
-	}
-
-	// Svelte store takes a private second argument
-	// StartStopNotifier could mutate state, and we want to silence the corresponding validation error
-	const unsub = untrack(() =>
-		store.subscribe(
-			run,
-			// @ts-expect-error
-			invalidate
-		)
-	);
-
-	// Also support RxJS
-	// @ts-expect-error TODO fix this in the types?
-	return unsub.unsubscribe ? () => unsub.unsubscribe() : unsub;
-}

data/lib/svelte_on_rails/node_modules/svelte/src/transition/index.js

@@ -1,300 +0,0 @@
-/** @import { BlurParams, CrossfadeParams, DrawParams, FadeParams, FlyParams, ScaleParams, SlideParams, TransitionConfig } from './public' */
-
-import { DEV } from 'esm-env';
-import * as w from '../internal/client/warnings.js';
-
-/** @param {number} x */
-const linear = (x) => x;
-
-/** @param {number} t */
-function cubic_out(t) {
-	const f = t - 1.0;
-	return f * f * f + 1.0;
-}
-
-/**
- * @param {number} t
- * @returns {number}
- */
-function cubic_in_out(t) {
-	return t < 0.5 ? 4.0 * t * t * t : 0.5 * Math.pow(2.0 * t - 2.0, 3.0) + 1.0;
-}
-
-/** @param {number | string} value
- * @returns {[number, string]}
- */
-function split_css_unit(value) {
-	const split = typeof value === 'string' && value.match(/^\s*(-?[\d.]+)([^\s]*)\s*$/);
-	return split ? [parseFloat(split[1]), split[2] || 'px'] : [/** @type {number} */ (value), 'px'];
-}
-
-/**
- * Animates a `blur` filter alongside an element's opacity.
- *
- * @param {Element} node
- * @param {BlurParams} [params]
- * @returns {TransitionConfig}
- */
-export function blur(
-	node,
-	{ delay = 0, duration = 400, easing = cubic_in_out, amount = 5, opacity = 0 } = {}
-) {
-	const style = getComputedStyle(node);
-	const target_opacity = +style.opacity;
-	const f = style.filter === 'none' ? '' : style.filter;
-	const od = target_opacity * (1 - opacity);
-	const [value, unit] = split_css_unit(amount);
-	return {
-		delay,
-		duration,
-		easing,
-		css: (_t, u) => `opacity: ${target_opacity - od * u}; filter: ${f} blur(${u * value}${unit});`
-	};
-}
-
-/**
- * Animates the opacity of an element from 0 to the current opacity for `in` transitions and from the current opacity to 0 for `out` transitions.
- *
- * @param {Element} node
- * @param {FadeParams} [params]
- * @returns {TransitionConfig}
- */
-export function fade(node, { delay = 0, duration = 400, easing = linear } = {}) {
-	const o = +getComputedStyle(node).opacity;
-	return {
-		delay,
-		duration,
-		easing,
-		css: (t) => `opacity: ${t * o}`
-	};
-}
-
-/**
- * Animates the x and y positions and the opacity of an element. `in` transitions animate from the provided values, passed as parameters to the element's default values. `out` transitions animate from the element's default values to the provided values.
- *
- * @param {Element} node
- * @param {FlyParams} [params]
- * @returns {TransitionConfig}
- */
-export function fly(
-	node,
-	{ delay = 0, duration = 400, easing = cubic_out, x = 0, y = 0, opacity = 0 } = {}
-) {
-	const style = getComputedStyle(node);
-	const target_opacity = +style.opacity;
-	const transform = style.transform === 'none' ? '' : style.transform;
-	const od = target_opacity * (1 - opacity);
-	const [x_value, x_unit] = split_css_unit(x);
-	const [y_value, y_unit] = split_css_unit(y);
-	return {
-		delay,
-		duration,
-		easing,
-		css: (t, u) => `
-			transform: ${transform} translate(${(1 - t) * x_value}${x_unit}, ${(1 - t) * y_value}${y_unit});
-			opacity: ${target_opacity - od * u}`
-	};
-}
-
-var slide_warning = false;
-
-/**
- * Slides an element in and out.
- *
- * @param {Element} node
- * @param {SlideParams} [params]
- * @returns {TransitionConfig}
- */
-export function slide(node, { delay = 0, duration = 400, easing = cubic_out, axis = 'y' } = {}) {
-	const style = getComputedStyle(node);
-
-	if (DEV && !slide_warning && /(contents|inline|table)/.test(style.display)) {
-		slide_warning = true;
-		Promise.resolve().then(() => (slide_warning = false));
-		w.transition_slide_display(style.display);
-	}
-
-	const opacity = +style.opacity;
-	const primary_property = axis === 'y' ? 'height' : 'width';
-	const primary_property_value = parseFloat(style[primary_property]);
-	const secondary_properties = axis === 'y' ? ['top', 'bottom'] : ['left', 'right'];
-	const capitalized_secondary_properties = secondary_properties.map(
-		(e) => /** @type {'Left' | 'Right' | 'Top' | 'Bottom'} */ (`${e[0].toUpperCase()}${e.slice(1)}`)
-	);
-	const padding_start_value = parseFloat(style[`padding${capitalized_secondary_properties[0]}`]);
-	const padding_end_value = parseFloat(style[`padding${capitalized_secondary_properties[1]}`]);
-	const margin_start_value = parseFloat(style[`margin${capitalized_secondary_properties[0]}`]);
-	const margin_end_value = parseFloat(style[`margin${capitalized_secondary_properties[1]}`]);
-	const border_width_start_value = parseFloat(
-		style[`border${capitalized_secondary_properties[0]}Width`]
-	);
-	const border_width_end_value = parseFloat(
-		style[`border${capitalized_secondary_properties[1]}Width`]
-	);
-	return {
-		delay,
-		duration,
-		easing,
-		css: (t) =>
-			'overflow: hidden;' +
-			`opacity: ${Math.min(t * 20, 1) * opacity};` +
-			`${primary_property}: ${t * primary_property_value}px;` +
-			`padding-${secondary_properties[0]}: ${t * padding_start_value}px;` +
-			`padding-${secondary_properties[1]}: ${t * padding_end_value}px;` +
-			`margin-${secondary_properties[0]}: ${t * margin_start_value}px;` +
-			`margin-${secondary_properties[1]}: ${t * margin_end_value}px;` +
-			`border-${secondary_properties[0]}-width: ${t * border_width_start_value}px;` +
-			`border-${secondary_properties[1]}-width: ${t * border_width_end_value}px;` +
-			`min-${primary_property}: 0`
-	};
-}
-
-/**
- * Animates the opacity and scale of an element. `in` transitions animate from the provided values, passed as parameters, to an element's current (default) values. `out` transitions animate from an element's default values to the provided values.
- *
- * @param {Element} node
- * @param {ScaleParams} [params]
- * @returns {TransitionConfig}
- */
-export function scale(
-	node,
-	{ delay = 0, duration = 400, easing = cubic_out, start = 0, opacity = 0 } = {}
-) {
-	const style = getComputedStyle(node);
-	const target_opacity = +style.opacity;
-	const transform = style.transform === 'none' ? '' : style.transform;
-	const sd = 1 - start;
-	const od = target_opacity * (1 - opacity);
-	return {
-		delay,
-		duration,
-		easing,
-		css: (_t, u) => `
-			transform: ${transform} scale(${1 - sd * u});
-			opacity: ${target_opacity - od * u}
-		`
-	};
-}
-
-/**
- * Animates the stroke of an SVG element, like a snake in a tube. `in` transitions begin with the path invisible and draw the path to the screen over time. `out` transitions start in a visible state and gradually erase the path. `draw` only works with elements that have a `getTotalLength` method, like `<path>` and `<polyline>`.
- *
- * @param {SVGElement & { getTotalLength(): number }} node
- * @param {DrawParams} [params]
- * @returns {TransitionConfig}
- */
-export function draw(node, { delay = 0, speed, duration, easing = cubic_in_out } = {}) {
-	let len = node.getTotalLength();
-	const style = getComputedStyle(node);
-	if (style.strokeLinecap !== 'butt') {
-		len += parseInt(style.strokeWidth);
-	}
-	if (duration === undefined) {
-		if (speed === undefined) {
-			duration = 800;
-		} else {
-			duration = len / speed;
-		}
-	} else if (typeof duration === 'function') {
-		duration = duration(len);
-	}
-	return {
-		delay,
-		duration,
-		easing,
-		css: (_, u) => `
-			stroke-dasharray: ${len};
-			stroke-dashoffset: ${u * len};
-		`
-	};
-}
-
-/**
- * @template T
- * @template S
- * @param {T} tar
- * @param {S} src
- * @returns {T & S}
- */
-function assign(tar, src) {
-	// @ts-ignore
-	for (const k in src) tar[k] = src[k];
-	return /** @type {T & S} */ (tar);
-}
-
-/**
- * The `crossfade` function creates a pair of [transitions](https://svelte.dev/docs/svelte/transition) called `send` and `receive`. When an element is 'sent', it looks for a corresponding element being 'received', and generates a transition that transforms the element to its counterpart's position and fades it out. When an element is 'received', the reverse happens. If there is no counterpart, the `fallback` transition is used.
- *
- * @param {CrossfadeParams & {
- * 	fallback?: (node: Element, params: CrossfadeParams, intro: boolean) => TransitionConfig;
- * }} params
- * @returns {[(node: any, params: CrossfadeParams & { key: any; }) => () => TransitionConfig, (node: any, params: CrossfadeParams & { key: any; }) => () => TransitionConfig]}
- */
-export function crossfade({ fallback, ...defaults }) {
-	/** @type {Map<any, Element>} */
-	const to_receive = new Map();
-	/** @type {Map<any, Element>} */
-	const to_send = new Map();
-
-	/**
-	 * @param {Element} from_node
-	 * @param {Element} node
-	 * @param {CrossfadeParams} params
-	 * @returns {TransitionConfig}
-	 */
-	function crossfade(from_node, node, params) {
-		const {
-			delay = 0,
-			duration = /** @param {number} d */ (d) => Math.sqrt(d) * 30,
-			easing = cubic_out
-		} = assign(assign({}, defaults), params);
-		const from = from_node.getBoundingClientRect();
-		const to = node.getBoundingClientRect();
-		const dx = from.left - to.left;
-		const dy = from.top - to.top;
-		const dw = from.width / to.width;
-		const dh = from.height / to.height;
-		const d = Math.sqrt(dx * dx + dy * dy);
-		const style = getComputedStyle(node);
-		const transform = style.transform === 'none' ? '' : style.transform;
-		const opacity = +style.opacity;
-		return {
-			delay,
-			duration: typeof duration === 'function' ? duration(d) : duration,
-			easing,
-			css: (t, u) => `
-			   opacity: ${t * opacity};
-			   transform-origin: top left;
-			   transform: ${transform} translate(${u * dx}px,${u * dy}px) scale(${t + (1 - t) * dw}, ${
-						t + (1 - t) * dh
-					});
-		   `
-		};
-	}
-
-	/**
-	 * @param {Map<any, Element>} items
-	 * @param {Map<any, Element>} counterparts
-	 * @param {boolean} intro
-	 * @returns {(node: any, params: CrossfadeParams & { key: any; }) => () => TransitionConfig}
-	 */
-	function transition(items, counterparts, intro) {
-		// @ts-expect-error TODO improve typings (are the public types wrong?)
-		return (node, params) => {
-			items.set(params.key, node);
-			return () => {
-				if (counterparts.has(params.key)) {
-					const other_node = counterparts.get(params.key);
-					counterparts.delete(params.key);
-					return crossfade(/** @type {Element} */ (other_node), node, params);
-				}
-				// if the node is disappearing altogether
-				// (i.e. wasn't claimed by the other list)
-				// then we need to supply an outro
-				items.delete(params.key);
-				return fallback && fallback(node, params, intro);
-			};
-		};
-	}
-	return [transition(to_send, to_receive, false), transition(to_receive, to_send, true)];
-}