lumen-plus 0.0.5 → 0.0.7

package/dist/utils/node_modules/svelte/src/index-client.js

@@ -0,0 +1,255 @@
+/** @import { ComponentContext, ComponentContextLegacy } from '#client' */
+/** @import { EventDispatcher } from './index.js' */
+/** @import { NotFunction } from './internal/types.js' */
+import { active_reaction, 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 { 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');
+}
+
+/**
+ * Returns an [`AbortSignal`](https://developer.mozilla.org/en-US/docs/Web/API/AbortSignal) that aborts when the current [derived](https://svelte.dev/docs/svelte/$derived) or [effect](https://svelte.dev/docs/svelte/$effect) re-runs or is destroyed.
+ *
+ * Must be called while a derived or effect is running.
+ *
+ * ```svelte
+ * <script>
+ * 	import { getAbortSignal } from 'svelte';
+ *
+ * 	let { id } = $props();
+ *
+ * 	async function getData(id) {
+ * 		const response = await fetch(`/items/${id}`, {
+ * 			signal: getAbortSignal()
+ * 		});
+ *
+ * 		return await response.json();
+ * 	}
+ *
+ * 	const data = $derived(await getData(id));
+ * </script>
+ * ```
+ */
+export function getAbortSignal() {
+	if (active_reaction === null) {
+		e.get_abort_signal_outside_reaction();
+	}
+
+	return (active_reaction.ac ??= new AbortController()).signal;
+}
+
+/**
+ * `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) {
+		e.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) {
+		e.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: null; // 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) {
+		e.lifecycle_outside_component('createEventDispatcher');
+	}
+
+	/**
+	 * @param [detail]
+	 * @param [options]
+	 */
+	return (type, detail, options) => {
+		const events = /** @type {Record<string, Function | Function[]>} */ (
+			active_component_context.s.$$events
+		)?.[/** @type {string} */ (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) {
+		e.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) {
+		e.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, fork } from './internal/client/reactivity/batch.js';
+export {
+	createContext,
+	getContext,
+	getAllContexts,
+	hasContext,
+	setContext
+} from './internal/client/context.js';
+export { hydratable } from './internal/client/hydratable.js';
+export { hydrate, mount, unmount } from './internal/client/render.js';
+export { tick, untrack, settled } from './internal/client/runtime.js';
+export { createRawSnippet } from './internal/client/dom/blocks/snippet.js';

package/dist/utils/node_modules/svelte/src/index-server.js

@@ -0,0 +1,56 @@
+/** @import { SSRContext } from '#server' */
+/** @import { Renderer } from './internal/server/renderer.js' */
+import { ssr_context } 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) {
+	/** @type {Renderer} */ (/** @type {SSRContext} */ (ssr_context).r).on_destroy(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 function fork() {
+	e.lifecycle_function_unavailable('fork');
+}
+
+export async function tick() {}
+
+export async function settled() {}
+
+export { getAbortSignal } from './internal/server/abort-signal.js';
+
+export {
+	createContext,
+	getAllContexts,
+	getContext,
+	hasContext,
+	setContext
+} from './internal/server/context.js';
+
+export { hydratable } from './internal/server/hydratable.js';
+
+export { createRawSnippet } from './internal/server/blocks/snippet.js';

package/dist/utils/node_modules/svelte/src/internal/client/constants.js

@@ -0,0 +1,73 @@
+// General flags
+export const DERIVED = 1 << 1;
+export const EFFECT = 1 << 2;
+export const RENDER_EFFECT = 1 << 3;
+/**
+ * An effect that does not destroy its child effects when it reruns.
+ * Runs as part of render effects, i.e. not eagerly as part of tree traversal or effect flushing.
+ */
+export const MANAGED_EFFECT = 1 << 24;
+/**
+ * An effect that does not destroy its child effects when it reruns (like MANAGED_EFFECT).
+ * Runs eagerly as part of tree traversal or effect flushing.
+ */
+export const BLOCK_EFFECT = 1 << 4;
+export const BRANCH_EFFECT = 1 << 5;
+export const ROOT_EFFECT = 1 << 6;
+export const BOUNDARY_EFFECT = 1 << 7;
+/**
+ * Indicates that a reaction is connected to an effect root — either it is an effect,
+ * or it is a derived that is depended on by at least one effect. If a derived has
+ * no dependents, we can disconnect it from the graph, allowing it to either be
+ * GC'd or reconnected later if an effect comes to depend on it again
+ */
+export const CONNECTED = 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;
+
+// Flags exclusive to effects
+/** Set once an effect that should run synchronously has run */
+export const EFFECT_RAN = 1 << 15;
+/**
+ * 'Transparent' effects do not create a transition boundary.
+ * This is on a block effect 99% of the time but may also be on a branch effect if its parent block effect was pruned
+ */
+export const EFFECT_TRANSPARENT = 1 << 16;
+export const EAGER_EFFECT = 1 << 17;
+export const HEAD_EFFECT = 1 << 18;
+export const EFFECT_PRESERVED = 1 << 19;
+export const USER_EFFECT = 1 << 20;
+export const EFFECT_OFFSCREEN = 1 << 25;
+
+// Flags exclusive to deriveds
+/**
+ * Tells that we marked this derived and its reactions as visited during the "mark as (maybe) dirty"-phase.
+ * Will be lifted during execution of the derived and during checking its dirty state (both are necessary
+ * because a derived might be checked but not executed).
+ */
+export const WAS_MARKED = 1 << 15;
+
+// Flags used for async
+export const REACTION_IS_UPDATING = 1 << 21;
+export const ASYNC = 1 << 22;
+
+export const ERROR_VALUE = 1 << 23;
+
+export const STATE_SYMBOL = Symbol('$state');
+export const LEGACY_PROPS = Symbol('legacy props');
+export const LOADING_ATTR_SYMBOL = Symbol('');
+export const PROXY_PATH_SYMBOL = Symbol('proxy path');
+
+/** allow users to ignore aborted signal errors if `reason.name === 'StaleReactionError` */
+export const STALE_REACTION = new (class StaleReactionError extends Error {
+	name = 'StaleReactionError';
+	message = 'The reaction that called `getAbortSignal()` was re-run or destroyed';
+})();
+
+export const ELEMENT_NODE = 1;
+export const TEXT_NODE = 3;
+export const COMMENT_NODE = 8;
+export const DOCUMENT_FRAGMENT_NODE = 11;

package/dist/utils/node_modules/svelte/src/internal/client/context.js

@@ -0,0 +1,258 @@
+/** @import { ComponentContext, DevStackEntry, Effect } from '#client' */
+import { DEV } from 'esm-env';
+import * as e from './errors.js';
+import { active_effect, active_reaction } from './runtime.js';
+import { create_user_effect } from './reactivity/effects.js';
+import { async_mode_flag, legacy_mode_flag } from '../flags/index.js';
+import { FILENAME } from '../../constants.js';
+import { BRANCH_EFFECT, EFFECT_RAN } from './constants.js';
+
+/** @type {ComponentContext | null} */
+export let component_context = null;
+
+/** @param {ComponentContext | null} context */
+export function set_component_context(context) {
+	component_context = context;
+}
+
+/** @type {DevStackEntry | null} */
+export let dev_stack = null;
+
+/** @param {DevStackEntry | null} stack */
+export function set_dev_stack(stack) {
+	dev_stack = stack;
+}
+
+/**
+ * Execute a callback with a new dev stack entry
+ * @param {() => any} callback - Function to execute
+ * @param {DevStackEntry['type']} type - Type of block/component
+ * @param {any} component - Component function
+ * @param {number} line - Line number
+ * @param {number} column - Column number
+ * @param {Record<string, any>} [additional] - Any additional properties to add to the dev stack entry
+ * @returns {any}
+ */
+export function add_svelte_meta(callback, type, component, line, column, additional) {
+	const parent = dev_stack;
+
+	dev_stack = {
+		type,
+		file: component[FILENAME],
+		line,
+		column,
+		parent,
+		...additional
+	};
+
+	try {
+		return callback();
+	} finally {
+		dev_stack = parent;
+	}
+}
+
+/**
+ * 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;
+}
+
+/**
+ * Returns a `[get, set]` pair of functions for working with context in a type-safe way.
+ *
+ * `get` will throw an error if no parent component called `set`.
+ *
+ * @template T
+ * @returns {[() => T, (context: T) => T]}
+ * @since 5.40.0
+ */
+export function createContext() {
+	const key = {};
+
+	return [
+		() => {
+			if (!hasContext(key)) {
+				e.missing_context();
+			}
+
+			return getContext(key);
+		},
+		(context) => setContext(key, context)
+	];
+}
+
+/**
+ * Retrieves the context that belongs to the closest parent component with the specified `key`.
+ * Must be called during component initialisation.
+ *
+ * [`createContext`](https://svelte.dev/docs/svelte/svelte#createContext) is a type-safe alternative.
+ *
+ * @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.
+ *
+ * [`createContext`](https://svelte.dev/docs/svelte/svelte#createContext) is a type-safe alternative.
+ *
+ * @template T
+ * @param {any} key
+ * @param {T} context
+ * @returns {T}
+ */
+export function setContext(key, context) {
+	const context_map = get_or_init_context_map('setContext');
+
+	if (async_mode_flag) {
+		var flags = /** @type {Effect} */ (active_effect).f;
+		var valid =
+			!active_reaction &&
+			(flags & BRANCH_EFFECT) !== 0 &&
+			// pop() runs synchronously, so this indicates we're setting context after an await
+			!(/** @type {ComponentContext} */ (component_context).i);
+
+		if (!valid) {
+			e.set_context_after_init();
+		}
+	}
+
+	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) {
+	component_context = {
+		p: component_context,
+		i: false,
+		c: null,
+		e: null,
+		s: props,
+		x: null,
+		l: legacy_mode_flag && !runes ? { s: null, u: null, $: [] } : null
+	};
+
+	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) {
+	var context = /** @type {ComponentContext} */ (component_context);
+	var effects = context.e;
+
+	if (effects !== null) {
+		context.e = null;
+
+		for (var fn of effects) {
+			create_user_effect(fn);
+		}
+	}
+
+	if (component !== undefined) {
+		context.x = component;
+	}
+
+	context.i = true;
+
+	component_context = context.p;
+
+	if (DEV) {
+		dev_current_component_function = component_context?.function ?? null;
+	}
+
+	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) {
+		e.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;
+}