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

package/dist/index.js

@@ -10,7 +10,7 @@ var check_exports = /* @__PURE__ */ __exportAll({
 	isConditional: () => isConditional,
 	isDirective: () => isDirective,
 	isExpression: () => isExpression,
-	isFunction: () => isFunction,
+	isFunction: () => isFunction$1,
 	isIdentifier: () => isIdentifier,
 	isJSX: () => isJSX,
 	isJSXElement: () => isJSXElement,
@@ -61,7 +61,7 @@ const isReturnStatement = is(AST_NODE_TYPES.ReturnStatement);
 /** Check if a node is a class declaration or class expression. */
 const isClass = isOneOf([AST_NODE_TYPES.ClassDeclaration, AST_NODE_TYPES.ClassExpression]);
 /** Check if a node is a function declaration, function expression, or arrow function expression. */
-const isFunction = isOneOf([
+const isFunction$1 = isOneOf([
 	AST_NODE_TYPES.ArrowFunctionExpression,
 	AST_NODE_TYPES.FunctionDeclaration,
 	AST_NODE_TYPES.FunctionExpression
@@ -178,16 +178,6 @@ const isConditional = isOneOf([
 //#endregion
 //#region ../../.pkgs/eff/dist/index.js
 /**
-* A function that checks if the passed parameter is a string and narrows its type accordingly.
-*
-* @param data - The variable to check.
-* @returns True if the passed input is a string, false otherwise.
-* @category guards
-*/
-function isString(data) {
-	return typeof data === "string";
-}
-/**
 * Applies a `pipe` method's variadic arguments to an initial value from left
 * to right.
 *
@@ -219,7 +209,7 @@ function isString(data) {
 *   (n) => n + 2,
 *   (n) => n * 3
 * )
-* console.log(result) // 21
+* result // => 21
 * ```
 *
 * @category combinators
@@ -276,16 +266,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.
 *
@@ -310,8 +290,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)
@@ -324,8 +304,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)
@@ -341,8 +321,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
@@ -387,9 +367,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
@@ -427,12 +406,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
@@ -450,9 +428,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
@@ -470,9 +447,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
@@ -490,9 +466,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
@@ -510,9 +485,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
@@ -531,12 +505,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
@@ -599,7 +572,6 @@ const absurd = (_) => {
 *   name: hole<string>()
 * })
 *
-* console.log(typeof buildUser) // "function"
 * ```
 *
 * @category utility types
@@ -607,56 +579,407 @@ 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`.
+*
+* **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`.
 *
-* Supports both data-first and data-last (`pipe`-friendly) call styles.
+* **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)
 *
-* @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 neither = Predicate.nor(Predicate.isString, Predicate.isNumber)
 *
-* // data-last
-* assert.deepStrictEqual(pipe([1, 2, 3, 2, 1], dropWhile((n: number) => n < 3)), [3, 2, 1])
+* neither(true) // => true
 * ```
-* @category array
+*
+* @see {@link or}
+* @see {@link not}
+* @category combinators
+* @since 2.0.0
 */
-const dropWhile = dual(2, (xs, pred) => {
-	const len = xs.length;
+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 `string`.
+*
+* **When to use**
+*
+* Use when you need a `Predicate` guard to narrow an `unknown` value to a
+* string.
+*
+* **Details**
+*
+* Uses `typeof input === "string"`.
+*
+* **Example** (Guarding strings)
+*
+* ```ts
+* import { Predicate } from "effect"
+*
+* const data: unknown = "hi"
+*
+* if (Predicate.isString(data)) {
+*   data.toUpperCase() // => "HI"
+* }
+* ```
+*
+* @see {@link isNumber}
+* @see {@link isBoolean}
+* @see {@link Refinement}
+* @category guards
+* @since 2.0.0
+*/
+function isString(input) {
+	return typeof input === "string";
+}
+/**
+* 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)
+*
+* ```ts
+* import { Predicate } from "effect"
+*
+* const data: unknown = () => 1
+*
+* if (Predicate.isFunction(data)) {
+*   data() // => 1
+* }
+* ```
+*
+* @see {@link isObjectKeyword}
+* @category guards
+* @since 2.0.0
+*/
+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/ast",
-  "version": "5.24.0-beta.2",
+  "version": "5.24.1",
   "description": "ESLint React's TSESTree AST utility module.",
   "homepage": "https://github.com/Rel1cx/eslint-react",
   "bugs": {
@@ -37,7 +37,7 @@
     "@local/configs": "0.0.0",
     "@local/eff": "0.0.0",
     "@local/testkit": "0.0.0",
-    "eslint": "^10.11.0",
+    "eslint": "^10.12.0",
     "tsdown": "^0.23.0",
     "typescript": "6.0.3",
     "vitest": "^5.0.3"