@eslint-react/jsx 0.6.2 → 0.7.1

package/dist/index.cjs

@@ -1,6 +1,6 @@
 'use strict';
 
-require('@typescript-eslint/scope-manager');
+var scopeManager = require('@typescript-eslint/scope-manager');
 var types = require('@typescript-eslint/types');
 var utils = require('@typescript-eslint/utils');
 var memo = require('micro-memoize');
@@ -562,7 +562,7 @@ const globalStore = globalThis[globalStoreId];
  *
  * @category guards
  * @since 2.0.0
- */ const isNullable = (input)=>input === null || input === undefined;
+ */ const isNullable$1 = (input)=>input === null || input === undefined;
 /**
  * @since 2.0.0
  */ /**
@@ -715,17 +715,17 @@ const BIT_27 = 134217728.0;
    *
    * @memberOf PCGRandom
    */ constructor(seedHi, seedLo, incHi, incLo){
-        if (isNullable(seedLo) && isNullable(seedHi)) {
+        if (isNullable$1(seedLo) && isNullable$1(seedHi)) {
             seedLo = Math.random() * 0xffffffff >>> 0;
             seedHi = 0;
-        } else if (isNullable(seedLo)) {
+        } else if (isNullable$1(seedLo)) {
             seedLo = seedHi;
             seedHi = 0;
         }
-        if (isNullable(incLo) && isNullable(incHi)) {
+        if (isNullable$1(incLo) && isNullable$1(incHi)) {
             incLo = this._state ? this._state[3] : defaultIncLo;
             incHi = this._state ? this._state[2] : defaultIncHi;
-        } else if (isNullable(incLo)) {
+        } else if (isNullable$1(incLo)) {
             incLo = incHi;
             incHi = 0;
         }
@@ -6183,6 +6183,23 @@ Function.call.bind(Object.hasOwnProperty);
  * @category guards
  * @since 2.0.0
  */ const isString$1 = (input)=>typeof input === "string";
+/**
+ * A guard that succeeds when the input is `null` or `undefined`.
+ *
+ * @param input - The value to test.
+ *
+ * @example
+ * import { isNullable } from "effect/Predicate"
+ *
+ * assert.deepStrictEqual(isNullable(null), true)
+ * assert.deepStrictEqual(isNullable(undefined), true)
+ *
+ * assert.deepStrictEqual(isNullable({}), false)
+ * assert.deepStrictEqual(isNullable([]), false)
+ *
+ * @category guards
+ * @since 2.0.0
+ */ const isNullable = (input)=>input === null || input === undefined;
 const t$1 = Symbol.for("@ts-pattern/matcher"), e$1 = Symbol.for("@ts-pattern/isVariadic"), n$1 = "@ts-pattern/anonymous-select-key", r$1 = (t)=>Boolean(t && "object" == typeof t), i$1 = (e)=>e && !!e[t$1], s$1 = (n, o, c)=>{
     if (i$1(n)) {
         const e = n[t$1](), { matched: r, selections: i } = e.match(o);
@@ -6216,6 +6233,17 @@ const t$1 = Symbol.for("@ts-pattern/matcher"), e$1 = Symbol.for("@ts-pattern/isV
     var n, s, a;
     return r$1(e) ? i$1(e) ? null != (n = null == (s = (a = e[t$1]()).getSelectionKeys) ? void 0 : s.call(a)) ? n : [] : Array.isArray(e) ? c$1(e, o$1) : c$1(Object.values(e), o$1) : [];
 }, c$1 = (t, e)=>t.reduce((t, n)=>t.concat(e(n)), []);
+function a$1(...t) {
+    if (1 === t.length) {
+        const [e] = t;
+        return (t)=>s$1(e, t, ()=>{});
+    }
+    if (2 === t.length) {
+        const [e, n] = t;
+        return s$1(e, n, ()=>{});
+    }
+    throw new Error(`isMatching wasn't given the right number of arguments: expected 1 or 2, received ${t.length}.`);
+}
 function u$1(t) {
     return Object.assign(t, {
         optional: ()=>l$1(t),
@@ -6224,6 +6252,18 @@ function u$1(t) {
         select: (e)=>void 0 === e ? p$1(t) : p$1(e, t)
     });
 }
+function h(t) {
+    return Object.assign(((t)=>Object.assign(t, {
+            *[Symbol.iterator] () {
+                yield Object.assign(t, {
+                    [e$1]: !0
+                });
+            }
+        }))(t), {
+        optional: ()=>h(l$1(t)),
+        select: (e)=>h(void 0 === e ? p$1(t) : p$1(e, t))
+    });
+}
 function l$1(e) {
     return u$1({
         [t$1]: ()=>({
@@ -6245,6 +6285,13 @@ function l$1(e) {
             })
     });
 }
+const f = (t, e)=>{
+    for (const n of t)if (!e(n)) return !1;
+    return !0;
+}, g = (t, e)=>{
+    for (const [n, r] of t.entries())if (!e(r, n)) return !1;
+    return !0;
+};
 function m$1(...e) {
     return u$1({
         [t$1]: ()=>({
@@ -6320,10 +6367,9 @@ function b$1(t) {
 function w$1(t) {
     return "bigint" == typeof t;
 }
-u$1(d$1(function(t) {
+const S = u$1(d$1(function(t) {
     return !0;
-}));
-const j$1 = (t)=>Object.assign(u$1(t), {
+})), O = S, j$1 = (t)=>Object.assign(u$1(t), {
         startsWith: (e)=>{
             return j$1(m$1(t, (n = e, d$1((t)=>b$1(t) && t.startsWith(n)))));
             var n;
@@ -6342,9 +6388,7 @@ const j$1 = (t)=>Object.assign(u$1(t), {
             return j$1(m$1(t, (n = e, d$1((t)=>b$1(t) && Boolean(t.match(n))))));
             var n;
         }
-    });
-j$1(d$1(b$1));
-const K$1 = (t)=>Object.assign(u$1(t), {
+    }), E = j$1(d$1(b$1)), K$1 = (t)=>Object.assign(u$1(t), {
         between: (e, n)=>K$1(m$1(t, ((t, e)=>d$1((n)=>v$1(n) && t <= n && e >= n))(e, n))),
         lt: (e)=>K$1(m$1(t, ((t)=>d$1((e)=>v$1(e) && e < t))(e))),
         gt: (e)=>K$1(m$1(t, ((t)=>d$1((e)=>v$1(e) && e > t))(e))),
@@ -6354,9 +6398,7 @@ const K$1 = (t)=>Object.assign(u$1(t), {
         finite: ()=>K$1(m$1(t, d$1((t)=>v$1(t) && Number.isFinite(t)))),
         positive: ()=>K$1(m$1(t, d$1((t)=>v$1(t) && t > 0))),
         negative: ()=>K$1(m$1(t, d$1((t)=>v$1(t) && t < 0)))
-    });
-K$1(d$1(v$1));
-const x$1 = (t)=>Object.assign(u$1(t), {
+    }), A = K$1(d$1(v$1)), x$1 = (t)=>Object.assign(u$1(t), {
         between: (e, n)=>x$1(m$1(t, ((t, e)=>d$1((n)=>w$1(n) && t <= n && e >= n))(e, n))),
         lt: (e)=>x$1(m$1(t, ((t)=>d$1((e)=>w$1(e) && e < t))(e))),
         gt: (e)=>x$1(m$1(t, ((t)=>d$1((e)=>w$1(e) && e > t))(e))),
@@ -6364,17 +6406,148 @@ const x$1 = (t)=>Object.assign(u$1(t), {
         gte: (e)=>x$1(m$1(t, ((t)=>d$1((e)=>w$1(e) && e >= t))(e))),
         positive: ()=>x$1(m$1(t, d$1((t)=>w$1(t) && t > 0))),
         negative: ()=>x$1(m$1(t, d$1((t)=>w$1(t) && t < 0)))
-    });
-x$1(d$1(w$1));
-u$1(d$1(function(t) {
+    }), P = x$1(d$1(w$1)), T = u$1(d$1(function(t) {
     return "boolean" == typeof t;
-}));
-u$1(d$1(function(t) {
+})), k = u$1(d$1(function(t) {
     return "symbol" == typeof t;
-}));
-u$1(d$1(function(t) {
+})), B = u$1(d$1(function(t) {
     return null == t;
 }));
+var _ = {
+    __proto__: null,
+    matcher: t$1,
+    optional: l$1,
+    array: function(...e) {
+        return h({
+            [t$1]: ()=>({
+                    match: (t)=>{
+                        if (!Array.isArray(t)) return {
+                            matched: !1
+                        };
+                        if (0 === e.length) return {
+                            matched: !0
+                        };
+                        const n = e[0];
+                        let r = {};
+                        if (0 === t.length) return o$1(n).forEach((t)=>{
+                            r[t] = [];
+                        }), {
+                            matched: !0,
+                            selections: r
+                        };
+                        const i = (t, e)=>{
+                            r[t] = (r[t] || []).concat([
+                                e
+                            ]);
+                        };
+                        return {
+                            matched: t.every((t)=>s$1(n, t, i)),
+                            selections: r
+                        };
+                    },
+                    getSelectionKeys: ()=>0 === e.length ? [] : o$1(e[0])
+                })
+        });
+    },
+    set: function(...e) {
+        return u$1({
+            [t$1]: ()=>({
+                    match: (t)=>{
+                        if (!(t instanceof Set)) return {
+                            matched: !1
+                        };
+                        let n = {};
+                        if (0 === t.size) return {
+                            matched: !0,
+                            selections: n
+                        };
+                        if (0 === e.length) return {
+                            matched: !0
+                        };
+                        const r = (t, e)=>{
+                            n[t] = (n[t] || []).concat([
+                                e
+                            ]);
+                        }, i = e[0];
+                        return {
+                            matched: f(t, (t)=>s$1(i, t, r)),
+                            selections: n
+                        };
+                    },
+                    getSelectionKeys: ()=>0 === e.length ? [] : o$1(e[0])
+                })
+        });
+    },
+    map: function(...e) {
+        return u$1({
+            [t$1]: ()=>({
+                    match: (t)=>{
+                        if (!(t instanceof Map)) return {
+                            matched: !1
+                        };
+                        let n = {};
+                        if (0 === t.size) return {
+                            matched: !0,
+                            selections: n
+                        };
+                        const r = (t, e)=>{
+                            n[t] = (n[t] || []).concat([
+                                e
+                            ]);
+                        };
+                        if (0 === e.length) return {
+                            matched: !0
+                        };
+                        var i;
+                        if (1 === e.length) throw new Error(`\`P.map\` wasn't given enough arguments. Expected (key, value), received ${null == (i = e[0]) ? void 0 : i.toString()}`);
+                        const [o, c] = e;
+                        return {
+                            matched: g(t, (t, e)=>{
+                                const n = s$1(o, e, r), i = s$1(c, t, r);
+                                return n && i;
+                            }),
+                            selections: n
+                        };
+                    },
+                    getSelectionKeys: ()=>0 === e.length ? [] : [
+                            ...o$1(e[0]),
+                            ...o$1(e[1])
+                        ]
+                })
+        });
+    },
+    intersection: m$1,
+    union: y$1,
+    not: function(e) {
+        return u$1({
+            [t$1]: ()=>({
+                    match: (t)=>({
+                            matched: !s$1(e, t, ()=>{})
+                        }),
+                    getSelectionKeys: ()=>[],
+                    matcherType: "not"
+                })
+        });
+    },
+    when: d$1,
+    select: p$1,
+    any: S,
+    _: O,
+    string: E,
+    number: A,
+    bigint: P,
+    boolean: T,
+    symbol: k,
+    nullish: B,
+    instanceOf: function(t) {
+        return u$1(d$1(function(t) {
+            return (e)=>e instanceof t;
+        }(t)));
+    },
+    shape: function(t) {
+        return u$1(d$1(a$1(t)));
+    }
+};
 const NodeType = types.AST_NODE_TYPES;
 const is = utils.ASTUtils.isNodeOfType;
 const isOneOf = utils.ASTUtils.isNodeOfTypes;
@@ -6563,6 +6736,54 @@ Construction.None();
     }
     return returnStatements;
 }
+/**
+ * Checks if the given node is a function expression or arrow function expression of a object method.
+ * @param node The node to check.
+ * @returns `true` if the node is a function expression or arrow function expression of a object method, `false` otherwise.
+ */ a$1({
+    type: _.union([
+        NodeType.FunctionExpression,
+        NodeType.ArrowFunctionExpression
+    ]),
+    parent: {
+        type: NodeType.Property,
+        parent: {
+            type: NodeType.ObjectExpression
+        }
+    }
+});
+/**
+ * Checks if the given node is a function expression or arrow function expression of a class method.
+ * @param node The node to check.
+ * @returns `true` if the node is a function expression or arrow function expression of a class method, `false` otherwise.
+ */ a$1({
+    type: _.union([
+        NodeType.FunctionExpression,
+        NodeType.ArrowFunctionExpression
+    ]),
+    parent: {
+        type: NodeType.MethodDefinition,
+        parent: {
+            type: NodeType.ClassBody
+        }
+    }
+});
+/**
+ * Checks if the given node is a function expression or arrow function expression of a class property.
+ * @param node The node to check.
+ * @returns `true` if the node is a function expression or arrow function expression of a class property, `false` otherwise.
+ */ a$1({
+    type: _.union([
+        NodeType.FunctionExpression,
+        NodeType.ArrowFunctionExpression
+    ]),
+    parent: {
+        type: NodeType.Property,
+        parent: {
+            type: NodeType.ClassBody
+        }
+    }
+});
 function isStringLiteral(node) {
     return node?.type === NodeType.Literal && isString$1(node.value);
 }
@@ -6605,7 +6826,7 @@ function isStringLiteral(node) {
     /**
    * @param variables The variables to search through
    */ return (variables)=>{
-        return effectOption_esm.fromNullable(variables.find((variable)=>"name" in variable && variable.name === name));
+        return effectOption_esm.fromNullable(variables.find((variable)=>variable.name === name));
     };
 }
 /**
@@ -6614,7 +6835,7 @@ function isStringLiteral(node) {
  */ function getVariablesUpToGlobal(startScope) {
     const scopeRef = effectMutableRef_esm.make(startScope);
     const variablesRef = effectMutableRef_esm.make(effectMutableRef_esm.get(scopeRef).variables);
-    while(effectMutableRef_esm.get(scopeRef).upper){
+    while(effectMutableRef_esm.get(scopeRef).type !== scopeManager.ScopeType.global){
         effectMutableRef_esm.set(scopeRef, effectMutableRef_esm.get(scopeRef).upper);
         effectMutableRef_esm.update(variablesRef, (variables)=>variables.concat(effectMutableRef_esm.get(scopeRef).variables));
     }
@@ -6625,26 +6846,23 @@ function isStringLiteral(node) {
  * @param name The name of the variable to find
  * @param startScope The scope to start from
  */ function findVariableByNameUpToGlobal(name, startScope) {
-    return effectFunction_esm.pipe(getVariablesUpToGlobal(startScope), findVariableByName(name));
+    return findVariableByName(name)(getVariablesUpToGlobal(startScope));
 }
-/**
- * Get the first definition of a variable
- * @param variable The variable to get the definition from
- */ function getVariableDefinitionFirst(variable) {
-    return effectOption_esm.fromNullable(variable.defs[0]);
+function resolveDefinitionInit(def) {
+    if ("init" in def.node && !isNullable(def.node.init)) {
+        return effectOption_esm.some(def.node.init);
+    }
+    // TODO: support other types of definitions
+    return effectOption_esm.none();
 }
 /**
  * Get the init node of the nth definition of a variable
- * @param variable
- * @param getDefinition A function that returns the nth definition of a variable
- */ function getVariableInit(variable, getDefinition) {
-    return effectFunction_esm.pipe(effectOption_esm.some(variable), effectOption_esm.flatMap(getDefinition), effectOption_esm.flatMapNullable((d)=>d.node), effectOption_esm.flatMapNullable((n)=>"init" in n ? n.init : null));
-}
-/**
- * Get the init node of the first definition of a variable
- * @param variable
- */ function getVariableInitFirst(variable) {
-    return getVariableInit(variable, getVariableDefinitionFirst);
+ * @param at The index number of def in defs
+ * @returns A function that takes a variable and returns the init node of the nth definition of that variable
+ */ function getVariableInit(at) {
+    return (variable)=>{
+        return effectFunction_esm.pipe(effectOption_esm.some(variable), effectOption_esm.flatMapNullable((v)=>v.defs.at(at)), effectOption_esm.flatMap(resolveDefinitionInit));
+    };
 }
 
 /**
@@ -7073,10 +7291,11 @@ function isFragmentWithSingleExpression(node) {
 
 /* eslint-disable perfectionist/sort-objects */ const JSXValueCheckHint = {
     None: 0n,
-    IgnoreNull: 1n << 0n,
-    IgnoreCreateElement: 1n << 1n,
-    StrictLogical: 1n << 2n,
-    StrictConditional: 1n << 3n
+    SkipNull: 1n << 0n,
+    SkipCreateElement: 1n << 1n,
+    StrictArray: 1n << 2n,
+    StrictLogical: 1n << 3n,
+    StrictConditional: 1n << 4n
 };
 /* eslint-enable perfectionist/sort-objects */ /**
  * Check if a node is a JSX value
@@ -7092,13 +7311,27 @@ function isFragmentWithSingleExpression(node) {
         type: NodeType.JSXElement
     }, effectFunction_esm.constTrue).with({
         type: NodeType.JSXFragment
+    }, effectFunction_esm.constTrue).with({
+        type: NodeType.JSXMemberExpression
+    }, effectFunction_esm.constTrue).with({
+        type: NodeType.JSXNamespacedName
     }, effectFunction_esm.constTrue).with({
         type: NodeType.Literal
     }, (node)=>{
-        if (!("value" in node) || hint & JSXValueCheckHint.IgnoreNull) {
+        if (!("value" in node) || hint & JSXValueCheckHint.SkipNull) {
             return false;
         }
         return node.value === null;
+    }).with({
+        type: NodeType.ArrayExpression
+    }, (node)=>{
+        if (!("elements" in node)) {
+            return false;
+        }
+        if (hint & JSXValueCheckHint.StrictArray) {
+            return node.elements.every((n)=>isJSXValue(n, context, hint));
+        }
+        return node.elements.some((n)=>isJSXValue(n, context, hint));
     }).with({
         type: NodeType.ConditionalExpression
     }, (node)=>{
@@ -7139,29 +7372,22 @@ function isFragmentWithSingleExpression(node) {
     }).with({
         type: NodeType.CallExpression
     }, (node)=>{
-        if (hint & JSXValueCheckHint.IgnoreCreateElement) {
+        if (hint & JSXValueCheckHint.SkipCreateElement) {
             return false;
         }
         return isCreateElementCall(node, context);
     }).with({
         type: NodeType.Identifier
     }, (node)=>{
-        if (!("name" in node)) {
-            return false;
-        }
         if (isJSXTagNameExpression(node)) {
             return true;
         }
-        const variable = findVariableByNameUpToGlobal(node.name, context.getScope());
-        return effectFunction_esm.pipe(variable, effectOption_esm.flatMap(getVariableInitFirst), effectOption_esm.filter(isOneOf([
+        const maybeVariable = findVariableByNameUpToGlobal(node.name, context.getScope());
+        return effectFunction_esm.pipe(maybeVariable, effectOption_esm.flatMap(getVariableInit(0)), effectOption_esm.filter(isOneOf([
             NodeType.JSXElement,
             NodeType.JSXFragment
         ])), effectOption_esm.isSome);
-    }).with({
-        type: NodeType.JSXMemberExpression
-    }, effectFunction_esm.constTrue).with({
-        type: NodeType.JSXNamespacedName
-    }, effectFunction_esm.constTrue).otherwise(effectFunction_esm.constFalse);
+    }).otherwise(effectFunction_esm.constFalse);
 }
 
 /**
@@ -7196,7 +7422,7 @@ function isFragmentWithSingleExpression(node) {
             }).when(is(NodeType.SpreadElement), (prop)=>{
                 return N(prop.argument).when(is(NodeType.Identifier), (argument)=>{
                     const { name } = argument;
-                    const maybeInit = effectOption_esm.flatMap(findVariableByNameUpToGlobal(name, startScope), getVariableInitFirst);
+                    const maybeInit = effectOption_esm.flatMap(findVariableByNameUpToGlobal(name, startScope), getVariableInit(0));
                     if (effectOption_esm.isNone(maybeInit)) {
                         return false;
                     }
@@ -7251,7 +7477,7 @@ function isFragmentWithSingleExpression(node) {
                     type: NodeType.Identifier
                 }, (argument)=>{
                     const { name } = argument;
-                    const maybeInit = effectOption_esm.flatMap(findVariableByNameUpToGlobal(name, startScope), getVariableInitFirst);
+                    const maybeInit = effectOption_esm.flatMap(findVariableByNameUpToGlobal(name, startScope), getVariableInit(0));
                     if (effectOption_esm.isNone(maybeInit)) {
                         return false;
                     }

package/dist/index.d.mts

@@ -232,8 +232,9 @@ declare function isPaddingSpaces(node: TSESTree.Node): boolean;
 
 declare const JSXValueCheckHint: {
     readonly None: 0n;
-    readonly IgnoreNull: bigint;
-    readonly IgnoreCreateElement: bigint;
+    readonly SkipNull: bigint;
+    readonly SkipCreateElement: bigint;
+    readonly StrictArray: bigint;
     readonly StrictLogical: bigint;
     readonly StrictConditional: bigint;
 };

package/dist/index.d.ts

@@ -232,8 +232,9 @@ declare function isPaddingSpaces(node: TSESTree.Node): boolean;
 
 declare const JSXValueCheckHint: {
     readonly None: 0n;
-    readonly IgnoreNull: bigint;
-    readonly IgnoreCreateElement: bigint;
+    readonly SkipNull: bigint;
+    readonly SkipCreateElement: bigint;
+    readonly StrictArray: bigint;
     readonly StrictLogical: bigint;
     readonly StrictConditional: bigint;
 };