@eslint-react/core 5.24.0-beta.2 → 5.24.1

package/dist/index.d.ts

@@ -427,7 +427,7 @@ export type FunctionSemanticNode = ClientFunctionSemanticNode | ServerFunctionSe
  * @param node The function node to analyze.
  * @returns The identifier node if found, `null` otherwise.
  */
-export declare function getFunctionId(node: TSESTree.Expression | TSESTreeFunction): TSESTree.ArrayExpression | TSESTree.ArrayPattern | TSESTree.ArrowFunctionExpressionWithBlockBody | TSESTree.ArrowFunctionExpressionWithExpressionBody | TSESTree.AssignmentExpression | TSESTree.AwaitExpression | TSESTree.PrivateInExpression | TSESTree.SymmetricBinaryExpression | TSESTree.CallExpression | TSESTree.ChainExpression | TSESTree.ClassExpression | TSESTree.ConditionalExpression | TSESTree.FunctionExpression | TSESTree.Identifier | TSESTree.ImportExpression | TSESTree.JSXElement | TSESTree.JSXFragment | TSESTree.BigIntLiteral | TSESTree.BooleanLiteral | TSESTree.NullLiteral | TSESTree.NumberLiteral | TSESTree.RegExpLiteral | TSESTree.StringLiteral | TSESTree.LogicalExpression | TSESTree.MemberExpressionComputedName | TSESTree.MemberExpressionNonComputedName | TSESTree.MetaProperty | TSESTree.NewExpression | TSESTree.ObjectExpression | TSESTree.ObjectPattern | TSESTree.PrivateIdentifier | TSESTree.SequenceExpression | TSESTree.Super | TSESTree.TaggedTemplateExpression | TSESTree.TemplateLiteral | TSESTree.ThisExpression | TSESTree.TSAsExpression | TSESTree.TSInstantiationExpression | TSESTree.TSNonNullExpression | TSESTree.TSSatisfiesExpression | TSESTree.TSTypeAssertion | TSESTree.UnaryExpressionBitwiseNot | TSESTree.UnaryExpressionDelete | TSESTree.UnaryExpressionMinus | TSESTree.UnaryExpressionNot | TSESTree.UnaryExpressionPlus | TSESTree.UnaryExpressionTypeof | TSESTree.UnaryExpressionVoid | TSESTree.UpdateExpression | TSESTree.YieldNoStarExpression | TSESTree.YieldStarExpression | null;
+export declare function getFunctionId(node: TSESTree.Expression | TSESTreeFunction): TSESTree.ArrayExpression | TSESTree.ArrayPattern | TSESTree.ArrowFunctionExpressionWithBlockBody | TSESTree.ArrowFunctionExpressionWithExpressionBody | TSESTree.AssignmentExpression | TSESTree.AwaitExpression | TSESTree.PrivateInExpression | TSESTree.SymmetricBinaryExpression | TSESTree.CallExpression | TSESTree.ChainExpression | TSESTree.ClassExpression | TSESTree.ConditionalExpression | TSESTree.FunctionExpression | TSESTree.Identifier | TSESTree.ImportExpression | TSESTree.JSXElement | TSESTree.JSXFragment | TSESTree.BigIntLiteral | TSESTree.BooleanLiteral | TSESTree.NullLiteral | TSESTree.NumberLiteral | TSESTree.RegExpLiteral | TSESTree.StringLiteral | TSESTree.TemplateLiteral | TSESTree.LogicalExpression | TSESTree.MemberExpressionComputedName | TSESTree.MemberExpressionNonComputedName | TSESTree.MetaProperty | TSESTree.NewExpression | TSESTree.ObjectExpression | TSESTree.ObjectPattern | TSESTree.SequenceExpression | TSESTree.Super | TSESTree.TaggedTemplateExpression | TSESTree.ThisExpression | TSESTree.TSAsExpression | TSESTree.TSInstantiationExpression | TSESTree.TSNonNullExpression | TSESTree.TSSatisfiesExpression | TSESTree.TSTypeAssertion | TSESTree.UnaryExpressionBitwiseNot | TSESTree.UnaryExpressionDelete | TSESTree.UnaryExpressionMinus | TSESTree.UnaryExpressionNot | TSESTree.UnaryExpressionPlus | TSESTree.UnaryExpressionTypeof | TSESTree.UnaryExpressionVoid | TSESTree.UpdateExpression | TSESTree.YieldNoStarExpression | TSESTree.YieldStarExpression | TSESTree.PrivateIdentifier | null;
 /**
  * Get the initialization path of a function node in the AST.
  *

package/dist/index.js

@@ -862,7 +862,7 @@ function isFunctionComponentDefinition(context, node, hint) {
 *   (n) => n + 2,
 *   (n) => n * 3
 * )
-* console.log(result) // 21
+* result // => 21
 * ```
 *
 * @category combinators
@@ -919,16 +919,6 @@ const Class = (function() {
 	return PipeableBase;
 })();
 /**
-* Provides small helpers for defining and reusing TypeScript functions.
-*
-* The main helpers are `pipe` and `flow` for left-to-right composition and
-* `dual` for APIs that support both direct and pipe-friendly call styles. The
-* module also contains small identity, constant, tuple, type-level, and
-* memoization helpers used across the library.
-*
-* @since 2.0.0
-*/
-/**
 * Creates a function that can be called in data-first style or data-last
 * (`pipe`-friendly) style.
 *
@@ -953,8 +943,8 @@ const Class = (function() {
 *   (self: number, that: number) => number
 * >(2, (self, that) => self + that)
 *
-* console.log(sum(2, 3)) // 5
-* console.log(pipe(2, sum(3))) // 5
+* sum(2, 3) // => 5
+* pipe(2, sum(3)) // => 5
 * ```
 *
 * **Example** (Defining overloads with call signatures)
@@ -967,8 +957,8 @@ const Class = (function() {
 *   (self: number, that: number): number
 * } = Function.dual(2, (self: number, that: number): number => self + that)
 *
-* console.log(sum(2, 3)) // 5
-* console.log(pipe(2, sum(3))) // 5
+* sum(2, 3) // => 5
+* pipe(2, sum(3)) // => 5
 * ```
 *
 * **Example** (Selecting data-first or data-last style with a predicate)
@@ -984,8 +974,8 @@ const Class = (function() {
 *   (self, that) => self + that
 * )
 *
-* console.log(sum(2, 3)) // 5
-* console.log(pipe(2, sum(3))) // 5
+* sum(2, 3) // => 5
+* pipe(2, sum(3)) // => 5
 * ```
 *
 * @category combinators
@@ -1030,9 +1020,8 @@ const dual = function(arity, body) {
 *
 * ```ts
 * import { identity } from "effect"
-* import * as assert from "node:assert"
 *
-* assert.deepStrictEqual(identity(5), 5)
+* identity(5) // => 5
 * ```
 *
 * @category combinators
@@ -1070,12 +1059,11 @@ const cast = identity;
 *
 * ```ts
 * import { Function } from "effect"
-* import * as assert from "node:assert"
 *
 * const constNull = Function.constant(null)
 *
-* assert.deepStrictEqual(constNull(), null)
-* assert.deepStrictEqual(constNull(), null)
+* constNull() // => null
+* constNull() // => null
 * ```
 *
 * @category constructors
@@ -1093,9 +1081,8 @@ const constant = (value) => () => value;
 *
 * ```ts
 * import { Function } from "effect"
-* import * as assert from "node:assert"
 *
-* assert.deepStrictEqual(Function.constTrue(), true)
+* Function.constTrue() // => true
 * ```
 *
 * @category constants
@@ -1113,9 +1100,8 @@ const constTrue = constant(true);
 *
 * ```ts
 * import { Function } from "effect"
-* import * as assert from "node:assert"
 *
-* assert.deepStrictEqual(Function.constFalse(), false)
+* Function.constFalse() // => false
 * ```
 *
 * @category constants
@@ -1133,9 +1119,8 @@ const constFalse = constant(false);
 *
 * ```ts
 * import { Function } from "effect"
-* import * as assert from "node:assert"
 *
-* assert.deepStrictEqual(Function.constNull(), null)
+* Function.constNull() // => null
 * ```
 *
 * @category constants
@@ -1153,9 +1138,8 @@ const constNull = constant(null);
 *
 * ```ts
 * import { Function } from "effect"
-* import * as assert from "node:assert"
 *
-* assert.deepStrictEqual(Function.constUndefined(), undefined)
+* Function.constUndefined() // => undefined
 * ```
 *
 * @category constants
@@ -1174,12 +1158,11 @@ const constUndefined = constant(void 0);
 *
 * ```ts
 * import { Function } from "effect"
-* import * as assert from "node:assert"
 *
 * const increment = (n: number) => n + 1
 * const square = (n: number) => n * n
 *
-* assert.strictEqual(Function.compose(increment, square)(2), 9)
+* Function.compose(increment, square)(2) // => 9
 * ```
 *
 * @see {@link flow} for composing a left-to-right sequence of functions
@@ -1242,7 +1225,6 @@ const absurd = (_) => {
 *   name: hole<string>()
 * })
 *
-* console.log(typeof buildUser) // "function"
 * ```
 *
 * @category utility types
@@ -1250,56 +1232,374 @@ const absurd = (_) => {
 */
 const hole = cast(absurd);
 /**
-* Drops the longest prefix of elements from an array that satisfy the given predicate.
+* Creates a predicate that returns `true` only if both predicates are `true`.
 *
-* Supports both data-first and data-last (`pipe`-friendly) call styles.
+* **When to use**
+*
+* Use when you want to combine `Predicate`s with AND, accepting values that
+* satisfy multiple conditions, including refinements that narrow to an
+* intersection.
+*
+* **Details**
+*
+* Evaluation short-circuits on the first `false`. For refinements, the output
+* type is an intersection.
+*
+* **Example** (Checking both conditions)
+*
+* ```ts
+* import { Predicate } from "effect"
+*
+* const hasAAndB = Predicate.and(
+*   Predicate.hasProperty("a"),
+*   Predicate.hasProperty("b")
+* )
+*
+* const input: unknown = JSON.parse(`{"a":1,"b":"ok"}`)
+* if (hasAAndB(input)) {
+*   // input has both properties at this point
+*   const a = input.a
+*   const b = input.b
+*
+*   const values = [a, b] // => [1, "ok"]
+* }
+* ```
+*
+* @see {@link or}
+* @see {@link not}
+* @category combinators
+* @since 2.0.0
+*/
+const and = dual(2, (a, b) => (data) => a(data) && b(data));
+/**
+* Creates a predicate that returns `true` if either predicate is `true`.
+*
+* **When to use**
+*
+* Use when you want to combine `Predicate`s with OR, accepting values that
+* satisfy at least one condition, including refinements that narrow to a union.
+*
+* **Details**
+*
+* Evaluation short-circuits on the first `true`. For refinements, the output
+* type is a union.
+*
+* **Example** (Checking either condition)
+*
+* ```ts
+* import { Predicate } from "effect"
+*
+* const isStringOrNumber = Predicate.or(Predicate.isString, Predicate.isNumber)
+*
+* isStringOrNumber("a") // => true
+* ```
+*
+* @see {@link and}
+* @see {@link xor}
+* @category combinators
+* @since 2.0.0
+*/
+const or = dual(2, (a, b) => (data) => a(data) || b(data));
+/**
+* Creates a predicate that returns `true` if exactly one predicate is `true`.
+*
+* **When to use**
+*
+* Use when you want to combine two `Predicate`s with exclusive-or semantics.
+*
+* **Details**
+*
+* Returns `true` when results differ.
+*
+* **Example** (Checking exclusive-or conditions)
+*
+* ```ts
+* import { Predicate } from "effect"
+*
+* const isEven = (n: number) => n % 2 === 0
+* const isPositive = (n: number) => n > 0
+* const either = Predicate.xor(isEven, isPositive)
+*
+* either(-2) // => true
+* ```
+*
+* @see {@link or}
+* @see {@link and}
+* @category combinators
+* @since 2.0.0
+*/
+const xor = dual(2, (a, b) => (data) => a(data) !== b(data));
+/**
+* Creates a predicate that returns `true` when both predicates agree.
+*
+* **When to use**
+*
+* Use when you want to check equivalence of two `Predicate`s.
+*
+* **Details**
+*
+* Returns `true` when both results are equal.
+*
+* **Example** (Defining equivalence)
+*
+* ```ts
+* import { Predicate } from "effect"
+*
+* const isEven = (n: number) => n % 2 === 0
+* const same = Predicate.eqv(isEven, isEven)
+*
+* same(3) // => true
+* ```
+*
+* @see {@link xor}
+* @category combinators
+* @since 2.0.0
+*/
+const eqv = dual(2, (a, b) => (data) => a(data) === b(data));
+/**
+* Creates a predicate representing logical implication: if `antecedent`, then `consequent`.
+*
+* **When to use**
+*
+* Use when you need to encode logical implication between `Predicate` rules,
+* where one rule only applies when a precondition holds.
+*
+* **Details**
+*
+* Models constraints like "if A then B" and returns `true` when the antecedent
+* is `false`.
+*
+* **Example** (Checking implication)
+*
+* ```ts
+* import { Predicate } from "effect"
+*
+* const isAdult = (age: number) => age >= 18
+* const canVote = (age: number) => age >= 18
+* const implies = Predicate.implies(isAdult, canVote)
+*
+* implies(16) // => true
+* ```
+*
+* @see {@link and}
+* @see {@link or}
+* @category combinators
+* @since 2.0.0
+*/
+const implies = dual(2, (antecedent, consequent) => (data) => !antecedent(data) || consequent(data));
+/**
+* Creates a predicate that returns `true` when neither predicate is `true`.
+*
+* **When to use**
+*
+* Use when you want to combine two `Predicate`s with logical NOR semantics.
+*
+* **Details**
+*
+* Returns the negation of `or`.
+*
+* **Example** (Checking NOR conditions)
+*
+* ```ts
+* import { Predicate } from "effect"
+*
+* const neither = Predicate.nor(Predicate.isString, Predicate.isNumber)
+*
+* neither(true) // => true
+* ```
+*
+* @see {@link or}
+* @see {@link not}
+* @category combinators
+* @since 2.0.0
+*/
+const nor = dual(2, (a, b) => (data) => !a(data) && !b(data));
+/**
+* Creates a predicate that returns `true` unless both predicates are `true`.
+*
+* **When to use**
+*
+* Use when you want to combine two `Predicate`s with logical NAND semantics.
+*
+* **Details**
+*
+* Returns the negation of `and`.
+*
+* **Example** (Checking NAND conditions)
+*
+* ```ts
+* import { Predicate } from "effect"
+*
+* const notBoth = Predicate.nand(Predicate.isString, Predicate.isNumber)
+*
+* notBoth("a") // => true
+* ```
+*
+* @see {@link and}
+* @see {@link not}
+* @category combinators
+* @since 2.0.0
+*/
+const nand = dual(2, (a, b) => (data) => !a(data) || !b(data));
+/**
+* Checks whether a value is a `function`.
+*
+* **When to use**
+*
+* Use when you need a `Predicate` guard to narrow an `unknown` value to a
+* callable function.
+*
+* **Details**
+*
+* Uses `typeof input === "function"`.
+*
+* **Example** (Guarding functions)
 *
-* @param pred - The predicate to test each element with.
-* @returns A new array without the matching prefix.
-* @example
 * ```ts
-* import * as assert from "node:assert"
-* import { dropWhile, pipe } from "@local/eff"
+* import { Predicate } from "effect"
 *
-* // data-first
-* assert.deepStrictEqual(dropWhile([1, 2, 3, 2, 1], (n: number) => n < 3), [3, 2, 1])
+* const data: unknown = () => 1
 *
-* // data-last
-* assert.deepStrictEqual(pipe([1, 2, 3, 2, 1], dropWhile((n: number) => n < 3)), [3, 2, 1])
+* if (Predicate.isFunction(data)) {
+*   data() // => 1
+* }
 * ```
-* @category array
+*
+* @see {@link isObjectKeyword}
+* @category guards
+* @since 2.0.0
 */
-const dropWhile = dual(2, (xs, pred) => {
-	const len = xs.length;
+function isFunction(input) {
+	return typeof input === "function";
+}
+/**
+* Checks whether a value is an `object` in the JavaScript sense (objects, arrays, functions).
+*
+* **When to use**
+*
+* Use when you need a `Predicate` guard that accepts arrays and functions as
+* well as objects.
+*
+* **Details**
+*
+* Returns `true` for arrays and functions, and `false` for `null`.
+*
+* **Example** (Checking object keywords)
+*
+* ```ts
+* import { Predicate } from "effect"
+*
+* Predicate.isObjectKeyword(() => 1) // => true
+* Predicate.isObjectKeyword(null) // => false
+* ```
+*
+* @see {@link isObject}
+* @see {@link isObjectOrArray}
+* @category guards
+* @since 4.0.0
+*/
+function isObjectKeyword(input) {
+	return typeof input === "object" && input !== null || isFunction(input);
+}
+/**
+* Checks whether a value has a given property key.
+*
+* **When to use**
+*
+* Use when you need a `Predicate` guard for property access on `unknown`
+* values with a simple structural object check.
+*
+* **Details**
+*
+* Uses the `in` operator and `isObjectKeyword`. This does not check property
+* value types.
+*
+* **Example** (Guarding object properties)
+*
+* ```ts
+* import { Predicate } from "effect"
+*
+* const hasName = Predicate.hasProperty("name")
+* const data: unknown = { name: "Ada" }
+*
+* if (hasName(data)) {
+*   data.name // => "Ada"
+* }
+* ```
+*
+* @see {@link isTagged}
+* @see {@link isObjectKeyword}
+* @category guards
+* @since 2.0.0
+*/
+const hasProperty = dual(2, (data, property) => isObjectKeyword(data) && property in data);
+/**
+* Drops elements from the start while the predicate holds, returning the rest.
+*
+* **When to use**
+*
+* Use to remove a leading prefix of elements that satisfy a predicate.
+*
+* **Details**
+*
+* The predicate receives `(element, index)`.
+*
+* **Example** (Dropping while condition holds)
+*
+* ```ts
+* import { Array } from "effect"
+*
+* Array.dropWhile([1, 2, 3, 4, 5], (x) => x < 4) // => [4, 5]
+* ```
+*
+* @see {@link takeWhile} — keep the matching prefix instead
+* @see {@link drop} — drop a fixed count
+*
+* @category getters
+* @since 2.0.0
+*/
+const dropWhile = dual(2, (self, predicate) => {
+	const input = Array.isArray(self) ? self : Array.from(self);
+	const len = input.length;
 	let idx = 0;
-	while (idx < len && pred(xs[idx])) idx++;
-	return xs.slice(idx);
+	while (idx < len && predicate(input[idx], idx)) idx++;
+	return input.slice(idx);
 });
 /**
-* Takes the longest prefix of elements from an array that satisfy the given predicate.
+* Takes elements from the start while the predicate holds, stopping at the
+* first element that fails.
 *
-* Supports both data-first and data-last (`pipe`-friendly) call styles.
+* **When to use**
 *
-* @param pred - The predicate to test each element with.
-* @returns A new array containing only the matching prefix.
-* @example
-* ```ts
-* import * as assert from "node:assert"
-* import { pipe, takeWhile } from "@local/eff"
+* Use to keep the leading elements of an iterable while each element satisfies
+* a predicate, returning the retained prefix as an array.
+*
+* **Details**
 *
-* // data-first
-* assert.deepStrictEqual(takeWhile([1, 2, 3, 2, 1], (n: number) => n < 3), [1, 2])
+* Supports refinements for type narrowing. The predicate receives
+* `(element, index)`.
 *
-* // data-last
-* assert.deepStrictEqual(pipe([1, 2, 3, 2, 1], takeWhile((n: number) => n < 3)), [1, 2])
+* **Example** (Taking while condition holds)
+*
+* ```ts
+* import { Array } from "effect"
+*
+* Array.takeWhile([1, 3, 2, 4, 1, 2], (x) => x < 4) // => [1, 3, 2]
 * ```
-* @category array
+*
+* @see {@link take} for keeping a fixed number of leading elements
+* @see {@link dropWhile} for removing the matching prefix and keeping the rest
+* @see {@link span} for splitting the matching prefix from the remaining elements
+*
+* @category getters
+* @since 2.0.0
 */
-const takeWhile = dual(2, (xs, pred) => {
-	const len = xs.length;
+const takeWhile = dual(2, (self, predicate) => {
+	const input = Array.isArray(self) ? self : Array.from(self);
+	const len = input.length;
 	let idx = 0;
-	while (idx < len && pred(xs[idx])) idx++;
-	return xs.slice(0, idx);
+	while (idx < len && predicate(input[idx], idx)) idx++;
+	return input.slice(0, idx);
 });
 
 //#endregion

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@eslint-react/core",
-  "version": "5.24.0-beta.2",
+  "version": "5.24.1",
   "description": "ESLint React's ESLint utility module for static analysis of React core APIs and patterns.",
   "homepage": "https://github.com/Rel1cx/eslint-react",
   "bugs": {
@@ -29,10 +29,10 @@
     "dist"
   ],
   "dependencies": {
-    "@eslint-react/ast": "5.24.0-beta.2",
-    "@eslint-react/eslint": "5.24.0-beta.2",
-    "@eslint-react/shared": "5.24.0-beta.2",
-    "@eslint-react/var": "5.24.0-beta.2",
+    "@eslint-react/ast": "5.24.1",
+    "@eslint-react/eslint": "5.24.1",
+    "@eslint-react/shared": "5.24.1",
+    "@eslint-react/var": "5.24.1",
     "@typescript-eslint/types": "^8.71.0",
     "@typescript-eslint/utils": "^8.71.0",
     "ts-pattern": "^5.9.0"
@@ -42,7 +42,7 @@
     "@local/eff": "0.0.0",
     "@local/testkit": "0.0.0",
     "@typescript-eslint/typescript-estree": "^8.71.0",
-    "eslint": "^10.11.0",
+    "eslint": "^10.12.0",
     "tsdown": "^0.23.0",
     "typescript": "6.0.3",
     "vitest": "^5.0.3"