@eslint-react/eff 2.12.5-next.1 → 2.12.5-next.2

package/dist/index.d.ts

@@ -7,6 +7,10 @@ type unit = undefined;
  * alias for `undefined`.
  */
 declare const unit: undefined;
+/**
+ * Simplifies a complex type intersection into a flat object type for better readability
+ * in IDE tooltips and error messages.
+ */
 type Pretty<T> = { [P in keyof T]: T[P] } & {};
 /**
  * An extension of Extract for type predicates which falls back to the base
@@ -19,17 +23,17 @@ type NarrowedTo<T, Base> = Extract<T, Base> extends never ? Base : 0 extends 1 &
 /**
  * A function that takes a guard function as predicate and returns a guard that negates it.
  *
- * @param predicate The guard function to negate.
- * @returns Function A guard function.
+ * @param predicate - The guard function to negate.
+ * @returns A guard function that negates the given predicate.
  */
 declare function not<T, S extends T>(predicate: (data: T) => data is S): (data: T) => data is Exclude<T, S>;
 declare function not<T>(predicate: (data: T) => boolean): (data: T) => boolean;
 /**
  * A function that takes two guard functions as predicates and returns a guard that checks if either of them is true.
  *
- * @param a The first guard function.
- * @param b The second guard function.
- * @returns Function A guard function.
+ * @param a - The first guard function.
+ * @param b - The second guard function.
+ * @returns A guard function that checks if either predicate is true.
  */
 declare function or<T, S extends T, U extends T>(a: (data: T) => data is S, b: (data: T) => data is U): (data: T) => data is S | U;
 declare function or<T, S extends T>(a: (data: T) => data is S, b: (data: T) => boolean): (data: T) => data is S;
@@ -38,28 +42,29 @@ declare function or<T>(a: (data: T) => boolean, b: (data: T) => boolean): (data:
 /**
  * A function that checks if the passed parameter is an Array and narrows its type accordingly.
  *
- * @param data The variable to check.
- * @returns True if the passed input is an Array, false otherwise. s
+ * @param data - The variable to check.
+ * @returns True if the passed input is an Array, false otherwise.
  */
 declare function isArray<T>(data: ArrayLike<unknown> | T): data is NarrowedTo<T, ReadonlyArray<unknown>>;
 /**
- * Check if the given parameter is of type `"object"` via `typeof`, excluding `null`.
+ * Checks if the given parameter is of type `"object"` via `typeof`, excluding `null`.
  *
- * @param data The variable to be checked for being an object type.
+ * @param data - The variable to be checked for being an object type.
  * @returns The input type, narrowed to only objects.
  */
 declare function isObject<T>(data: T | object): data is NarrowedTo<T, object>;
 /**
  * A function that checks if the passed parameter is truthy and narrows its type accordingly.
  *
- * @param data The variable to check.
+ * @param data - The variable to check.
  * @returns True if the passed input is truthy, false otherwise.
  */
 declare function isTruthy<T>(data: T): data is Exclude<T, "" | 0 | false | null | undefined>;
 /**
  * Tests if a value is a `function`.
  *
- * @param input The value to test.
+ * @param input - The value to test.
+ * @returns `true` if the input is a function, `false` otherwise.
  * @example
  * ```ts
  * import * as assert from "node:assert"
@@ -74,7 +79,9 @@ declare function isTruthy<T>(data: T): data is Exclude<T, "" | 0 | false | null
 declare const isFunction: (input: unknown) => input is Function;
 /**
  * Returns its argument.
- * @param x The value to return.
+ *
+ * @param x - The value to return.
+ * @returns The input value unchanged.
  */
 declare function identity<T>(x: T): T;
 /**
@@ -139,8 +146,8 @@ declare function identity<T>(x: T): T;
  * console.log(pipe(2, sum(3))) // 5
  * ```
  *
- * @param arity The arity of the uncurried function or a predicate that determines if the function is being used in a data-first or data-last style.
- * @param body The function to be curried.
+ * @param arity - The arity of the uncurried function or a predicate that determines if the function is being used in a data-first or data-last style.
+ * @param body - The function to be curried.
  * @since 1.0.0
  */
 declare const dual: {
@@ -150,7 +157,8 @@ declare const dual: {
 /**
  * Apply a function to a given value.
  *
- * @param a The value to apply.
+ * @param a - The value to apply.
+ * @returns A function that takes a function and applies it to the given value.
  * @example
  * ```ts
  * import * as assert from "node:assert"
@@ -165,7 +173,9 @@ declare const dual: {
 declare const apply: <A>(a: A) => <B>(self: (a: A) => B) => B;
 /**
  * Returns a function that always returns the same value.
- * @param x The value to return.
+ *
+ * @param x - The value to return.
+ * @returns A function that always returns the given value.
  */
 declare function constant<T>(x: T): () => T;
 /**
@@ -174,20 +184,27 @@ declare function constant<T>(x: T): () => T;
 declare function constVoid(): void;
 /**
  * Do nothing and return `null`.
+ *
+ * @returns null
  */
 declare function constNull(): null;
 /**
  * Do nothing and return `true`.
+ *
+ * @returns true
  */
 declare function constTrue(): true;
 /**
  * Do nothing and return `false`.
+ *
+ * @returns false
  */
 declare function constFalse(): false;
 /**
  * Reverses the order of arguments for a curried function.
  *
- * @param f The function to flip.
+ * @param f - The function to flip.
+ * @returns A new function with the argument order reversed.
  * @example
  * ```ts
  * import * as assert from "node:assert"
@@ -205,6 +222,9 @@ declare const flip: <A extends Array<unknown>, B extends Array<unknown>, C>(f: (
  * Composes two functions, `ab` and `bc` into a single function that takes in an argument `a` of type `A` and returns a result of type `C`.
  * The result is obtained by first applying the `ab` function to `a` and then applying the `bc` function to the result of `ab`.
  *
+ * @param self - The first function to apply (or the composed function in data-last style).
+ * @param bc - The second function to apply.
+ * @returns A composed function that applies both functions in sequence.
  * @example
  * ```ts
  * import * as assert from "node:assert"
@@ -228,14 +248,15 @@ declare const compose: {
  *
  * This function is particularly useful when it's necessary to specify that certain cases are impossible.
  *
- * @param _ The value of type `never` that is passed to the function.
+ * @param _ - The value of type `never` that is passed to the function.
  * @since 1.0.0
  */
 declare const absurd: <A>(_: never) => A;
 /**
- * Creates a   version of this function: instead of `n` arguments, it accepts a single tuple argument.
+ * Creates a tupled version of this function: instead of `n` arguments, it accepts a single tuple argument.
  *
- * @param f The function to be converted.
+ * @param f - The function to be converted.
+ * @returns A new function that accepts a single tuple argument.
  * @example
  * ```ts
  * import * as assert from "node:assert"
@@ -252,7 +273,8 @@ declare const tupled: <A extends ReadonlyArray<unknown>, B>(f: (...a: A) => B) =
 /**
  * Inverse function of `tupled`.
  *
- * @param f The function to be converted.
+ * @param f - The function to be converted.
+ * @returns A new function that accepts spread arguments instead of a tuple.
  * @example
  * ```ts
  * import * as assert from "node:assert"
@@ -267,8 +289,12 @@ declare const tupled: <A extends ReadonlyArray<unknown>, B>(f: (...a: A) => B) =
  */
 declare const untupled: <A extends ReadonlyArray<unknown>, B>(f: (a: A) => B) => (...a: A) => B;
 /**
- * @param self The value to pipe.
- * @param args The functions to apply.
+ * Applies a pipeline of functions to a value, passing the result of each function
+ * to the next one in sequence.
+ *
+ * @param self - The value to pipe.
+ * @param args - The functions to apply.
+ * @returns The result of applying all functions in sequence.
  * @since 1.0.0
  */
 declare const pipeArguments: <A>(self: A, args: IArguments) => unknown;
@@ -338,8 +364,9 @@ declare const pipeArguments: <A>(self: A, args: IArguments) => unknown;
  * // Output: 2
  * ```
  *
- * @param a The value to pipe.
- * @param args
+ * @param a - The value to pipe.
+ * @param args - The functions to apply in sequence.
+ * @returns The result of applying all functions in sequence to the initial value.
  * @since 1.0.0
  */
 declare function pipe<A>(a: A): A;
@@ -367,15 +394,16 @@ declare function pipe<A, B = never, C = never, D = never, E = never, F = never,
  *
  * See also [`pipe`](#pipe).
  *
- * @param ab The first function to apply.
- * @param bc
- * @param cd
- * @param de
- * @param ef
- * @param fg
- * @param gh
- * @param hi
- * @param ij
+ * @param ab - The first function to apply.
+ * @param bc - The second function to apply.
+ * @param cd - The third function to apply.
+ * @param de - The fourth function to apply.
+ * @param ef - The fifth function to apply.
+ * @param fg - The sixth function to apply.
+ * @param gh - The seventh function to apply.
+ * @param hi - The eighth function to apply.
+ * @param ij - The ninth function to apply.
+ * @returns A composed function that applies all given functions in sequence.
  * @example
  * ```ts
  * import * as assert from "node:assert"
@@ -402,27 +430,30 @@ declare function flow<A extends ReadonlyArray<unknown>, B = never, C = never, D
 declare function flow<A extends ReadonlyArray<unknown>, B = never, C = never, D = never, E = never, F = never, G = never, H = never, I = never, J = never>(ab: (...a: A) => B, bc: (b: B) => C, cd: (c: C) => D, de: (d: D) => E, ef: (e: E) => F, fg: (f: F) => G, gh: (g: G) => H, hi: (h: H) => I, ij: (i: I) => J): (...a: A) => J;
 /**
  * Retrieves a value from a Map or WeakMap if the key exists, or computes a new value if it doesn't.
- * @param map The Map or WeakMap to get from
- * @param key The key to look up in the Map or WeakMap
- * @param callback The function to call to generate a new value if the key doesn't exist
+ *
+ * @param map - The Map or WeakMap to get from.
+ * @param key - The key to look up in the Map or WeakMap.
+ * @param callback - The function to call to generate a new value if the key doesn't exist.
+ * @returns The existing value for the key, or the computed fallback value.
  */
 declare function getOrElse<K extends WeakKey, V>(map: WeakMap<K, V>, key: K, callback: () => V): V;
 declare function getOrElse<K, V>(map: Map<K, V>, key: K, callback: () => V): V;
 /**
  * Retrieves a value from a Map or WeakMap if the key exists, or computes and stores a new value if it doesn't.
- * @param map The Map or WeakMap to get from or update
- * @param key The key to look up in the Map or WeakMap
- * @param callback The function to call to generate a new value if the key doesn't exist
- * @returns The existing value for the key, or the newly computed value
+ *
+ * @param map - The Map or WeakMap to get from or update.
+ * @param key - The key to look up in the Map or WeakMap.
+ * @param callback - The function to call to generate a new value if the key doesn't exist.
+ * @returns The existing value for the key, or the newly computed value.
  */
 declare function getOrElseUpdate<K extends WeakKey, V>(map: WeakMap<K, V>, key: K, callback: () => V): V;
 declare function getOrElseUpdate<K, V>(map: Map<K, V>, key: K, callback: () => V): V;
 /**
  * Attempts to add a value to a Set, but only if it doesn't already exist.
  *
- * @param set The Set to potentially add to
- * @param value The value to add if it doesn't already exist in the Set
- * @returns true if the value was added, false if it already existed
+ * @param set - The Set to potentially add to.
+ * @param value - The value to add if it doesn't already exist in the Set.
+ * @returns `true` if the value was added, `false` if it already existed.
  */
 declare function tryAddToSet<T>(set: Set<T>, value: T): boolean;
 //#endregion

package/dist/index.js

@@ -12,16 +12,16 @@ function or(a, b) {
 /**
 * A function that checks if the passed parameter is an Array and narrows its type accordingly.
 *
-* @param data The variable to check.
-* @returns True if the passed input is an Array, false otherwise. s
+* @param data - The variable to check.
+* @returns True if the passed input is an Array, false otherwise.
 */
 function isArray(data) {
 	return Array.isArray(data);
 }
 /**
-* Check if the given parameter is of type `"object"` via `typeof`, excluding `null`.
+* Checks if the given parameter is of type `"object"` via `typeof`, excluding `null`.
 *
-* @param data The variable to be checked for being an object type.
+* @param data - The variable to be checked for being an object type.
 * @returns The input type, narrowed to only objects.
 */
 function isObject(data) {
@@ -30,7 +30,7 @@ function isObject(data) {
 /**
 * A function that checks if the passed parameter is truthy and narrows its type accordingly.
 *
-* @param data The variable to check.
+* @param data - The variable to check.
 * @returns True if the passed input is truthy, false otherwise.
 */
 function isTruthy(data) {
@@ -39,7 +39,8 @@ function isTruthy(data) {
 /**
 * Tests if a value is a `function`.
 *
-* @param input The value to test.
+* @param input - The value to test.
+* @returns `true` if the input is a function, `false` otherwise.
 * @example
 * ```ts
 * import * as assert from "node:assert"
@@ -54,7 +55,9 @@ function isTruthy(data) {
 const isFunction = (input) => typeof input === "function";
 /**
 * Returns its argument.
-* @param x The value to return.
+*
+* @param x - The value to return.
+* @returns The input value unchanged.
 */
 function identity(x) {
 	return x;
@@ -121,8 +124,8 @@ function identity(x) {
 * console.log(pipe(2, sum(3))) // 5
 * ```
 *
-* @param arity The arity of the uncurried function or a predicate that determines if the function is being used in a data-first or data-last style.
-* @param body The function to be curried.
+* @param arity - The arity of the uncurried function or a predicate that determines if the function is being used in a data-first or data-last style.
+* @param body - The function to be curried.
 * @since 1.0.0
 */
 const dual = function(arity, body) {
@@ -156,7 +159,8 @@ const dual = function(arity, body) {
 /**
 * Apply a function to a given value.
 *
-* @param a The value to apply.
+* @param a - The value to apply.
+* @returns A function that takes a function and applies it to the given value.
 * @example
 * ```ts
 * import * as assert from "node:assert"
@@ -171,7 +175,9 @@ const dual = function(arity, body) {
 const apply = (a) => (self) => self(a);
 /**
 * Returns a function that always returns the same value.
-* @param x The value to return.
+*
+* @param x - The value to return.
+* @returns A function that always returns the given value.
 */
 function constant(x) {
 	return () => x;
@@ -182,18 +188,24 @@ function constant(x) {
 function constVoid() {}
 /**
 * Do nothing and return `null`.
+*
+* @returns null
 */
 function constNull() {
 	return null;
 }
 /**
 * Do nothing and return `true`.
+*
+* @returns true
 */
 function constTrue() {
 	return true;
 }
 /**
 * Do nothing and return `false`.
+*
+* @returns false
 */
 function constFalse() {
 	return false;
@@ -201,7 +213,8 @@ function constFalse() {
 /**
 * Reverses the order of arguments for a curried function.
 *
-* @param f The function to flip.
+* @param f - The function to flip.
+* @returns A new function with the argument order reversed.
 * @example
 * ```ts
 * import * as assert from "node:assert"
@@ -219,6 +232,9 @@ const flip = (f) => (...b) => (...a) => f(...a)(...b);
 * Composes two functions, `ab` and `bc` into a single function that takes in an argument `a` of type `A` and returns a result of type `C`.
 * The result is obtained by first applying the `ab` function to `a` and then applying the `bc` function to the result of `ab`.
 *
+* @param self - The first function to apply (or the composed function in data-last style).
+* @param bc - The second function to apply.
+* @returns A composed function that applies both functions in sequence.
 * @example
 * ```ts
 * import * as assert from "node:assert"
@@ -239,16 +255,17 @@ const compose = dual(2, (ab, bc) => (a) => bc(ab(a)));
 *
 * This function is particularly useful when it's necessary to specify that certain cases are impossible.
 *
-* @param _ The value of type `never` that is passed to the function.
+* @param _ - The value of type `never` that is passed to the function.
 * @since 1.0.0
 */
 const absurd = (_) => {
 	throw new Error("Called `absurd` function which should be uncallable");
 };
 /**
-* Creates a   version of this function: instead of `n` arguments, it accepts a single tuple argument.
+* Creates a tupled version of this function: instead of `n` arguments, it accepts a single tuple argument.
 *
-* @param f The function to be converted.
+* @param f - The function to be converted.
+* @returns A new function that accepts a single tuple argument.
 * @example
 * ```ts
 * import * as assert from "node:assert"
@@ -265,7 +282,8 @@ const tupled = (f) => (a) => f(...a);
 /**
 * Inverse function of `tupled`.
 *
-* @param f The function to be converted.
+* @param f - The function to be converted.
+* @returns A new function that accepts spread arguments instead of a tuple.
 * @example
 * ```ts
 * import * as assert from "node:assert"
@@ -280,8 +298,12 @@ const tupled = (f) => (a) => f(...a);
 */
 const untupled = (f) => (...a) => f(a);
 /**
-* @param self The value to pipe.
-* @param args The functions to apply.
+* Applies a pipeline of functions to a value, passing the result of each function
+* to the next one in sequence.
+*
+* @param self - The value to pipe.
+* @param args - The functions to apply.
+* @returns The result of applying all functions in sequence.
 * @since 1.0.0
 */
 const pipeArguments = (self, args) => {
@@ -348,9 +370,9 @@ function getOrElseUpdate(map, key, callback) {
 /**
 * Attempts to add a value to a Set, but only if it doesn't already exist.
 *
-* @param set The Set to potentially add to
-* @param value The value to add if it doesn't already exist in the Set
-* @returns true if the value was added, false if it already existed
+* @param set - The Set to potentially add to.
+* @param value - The value to add if it doesn't already exist in the Set.
+* @returns `true` if the value was added, `false` if it already existed.
 */
 function tryAddToSet(set, value) {
 	if (!set.has(value)) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@eslint-react/eff",
-  "version": "2.12.5-next.1",
+  "version": "2.12.5-next.2",
   "description": "JavaScript and TypeScript utilities (previously some re-exports of the effect library).",
   "homepage": "https://github.com/Rel1cx/eslint-react",
   "bugs": {