Merge remote-tracking branch 'origin/from-action-remove-interface' into from-action

packages/svelte/src/attachments/index.js

@@ -1,7 +1,5 @@
-/**
+/** @import { Action, ActionReturn } from 'svelte/action' */
- * @import { Attachment } from "./public.js";
+/** @import { Attachment } from 'svelte/attachments' */
- * @import { ActionReturn } from "svelte/action";
- */
 import { noop, render_effect } from 'svelte/internal/client';
 import { ATTACHMENT_KEY } from '../constants.js';
 import { untrack } from 'svelte';
@@ -34,35 +32,41 @@ export function createAttachmentKey() {
 }
 
 /**
- * @template {EventTarget} [Element=HTMLElement]
+ * @template {EventTarget} E
- * @template {*} [Par=unknown]
+ * @template {unknown} T
- * @typedef {<Node extends Element, Parameter extends Par>(
+ * @overload
- * ...args: (undefined extends NoInfer<Parameter>
+ * @param {Action<E, T> | function(E, T): void | ActionReturn<T>} action The action function
- * ? [
+ * @param {() => T} fn A function that returns the argument for the action
- * action: (node: Node, parameter?: never) => void | ActionReturn<Parameter>,
+ * @returns {Attachment<E>}
- * parameter?: () => NoInfer<Parameter>
+ */
- * ]
+/**
- * : [
+ * @template {EventTarget} E
- * action: (node: Node, parameter: Parameter) => void | ActionReturn<Parameter>,
+ * @overload
- * parameter: () => NoInfer<Parameter>
+ * @param {Action<E, void> | function(E): void | ActionReturn<void>} action The action function
- * ])
+ * @returns {Attachment<E>}
- * ) => Attachment<Node>} FromAction
  */
-
 /**
  * Converts an Action into an Attachment keeping the same behavior. It's useful if you want to start using
  * attachments on Components but you have library provided actions.
- * @type {FromAction}
+ *
+ * Note that the second argument, if provided, must be a function that _returns_ the argument to the
+ * action function, not the argument itself.
+ *
+ * @template {EventTarget} E
+ * @template {unknown} T
+ * @param {Action<E, T> | function(E, T): void | ActionReturn<T>} action The action function
+ * @param {() => T} fn A function that returns the argument for the action
+ * @returns {Attachment<E>}
  * @since 5.32
  */
-export function fromAction(action, /** @type {() => any} */ get_arg = noop) {
+export function fromAction(action, fn = /** @type {() => T} */ (noop)) {
 	return (element) => {
-		const { update, destroy } = untrack(() => action(element, get_arg()) ?? {});
+		const { update, destroy } = untrack(() => action(element, fn()) ?? {});
 
 		if (update) {
 			var ran = false;
 			render_effect(() => {
-				const arg = get_arg();
+				const arg = fn();
 				if (ran) update(arg);
 			});
 			ran = true;

packages/svelte/types/index.d.ts

@@ -625,7 +625,7 @@ declare module 'svelte/animate' {
 }
 
 declare module 'svelte/attachments' {
-	import type { ActionReturn } from 'svelte/action';
+	import type { ActionReturn, Action } from 'svelte/action';
 	/**
 	 * An [attachment](https://svelte.dev/docs/svelte/@attach) is a function that runs when an element is mounted
 	 * to the DOM, and optionally returns a function that is called when the element is later removed.
@@ -659,8 +659,10 @@ declare module 'svelte/attachments' {
 	 * @since 5.29
 	 */
 	export function createAttachmentKey(): symbol;
-	export function fromAction<Node extends HTMLElement, Parameter extends unknown>(...args: undefined extends NoInfer<Parameter> ? [action: (node: Node, parameter?: never) => void | ActionReturn<Parameter, any>, parameter?: (() => NoInfer<Parameter>) | undefined] : [action: (node: Node, parameter: Parameter) => void | ActionReturn<Parameter, any>, parameter: () => NoInfer<Parameter>]): Attachment<Node>;
+
-	export type FromAction<Element extends EventTarget = HTMLElement, Par extends unknown = unknown> = <Node extends Element, Parameter extends Par>(...args: (undefined extends NoInfer<Parameter> ? [action: (node: Node, parameter?: never) => void | ActionReturn<Parameter>, parameter?: () => NoInfer<Parameter>] : [action: (node: Node, parameter: Parameter) => void | ActionReturn<Parameter>, parameter: () => NoInfer<Parameter>])) => Attachment<Node>;
+	export function fromAction<E extends EventTarget, T extends unknown>(action: Action<E, T> | ((arg0: E, arg1: T) => void | ActionReturn<T>), fn: () => T): Attachment<E>;
+
+	export function fromAction<E extends EventTarget>(action: Action<E, void> | ((arg0: E) => void | ActionReturn<void>)): Attachment<E>;
 
 	export {};
 }