@eslint-react/jsx 0.5.5

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2023 Eva1ent
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/dist/index.cjs

@@ -0,0 +1,594 @@
+'use strict';
+
+var tools = require('@eslint-react/tools');
+var memo = require('micro-memoize');
+var ast = require('@eslint-react/ast');
+var types = require('@typescript-eslint/types');
+
+/**
+ * Check if a JSXElement or JSXFragment has children
+ * @param node The AST node to check
+ * @returns `true` if the node has children
+ */ function hasChildren(node) {
+    return node.children.length > 0;
+}
+
+const RE_JSX_ANNOTATION_REGEX = /@jsx\s+(\S+)/u;
+// Does not check for reserved keywords or unicode characters
+const RE_JS_IDENTIFIER_REGEX = /^[$A-Z_a-z][\w$]*$/u;
+function getFragmentFromContext(context) {
+    // eslint-disable-next-line prefer-destructuring
+    const settings = context.settings;
+    const pragma = settings.react?.fragment ?? "Fragment";
+    if (!RE_JS_IDENTIFIER_REGEX.test(pragma)) {
+        return tools.E.left(new Error(`Fragment pragma ${pragma} is not a valid identifier`));
+    }
+    return tools.E.right(pragma);
+}
+const getPragmaFromContext = memo((context)=>{
+    // eslint-disable-next-line prefer-destructuring
+    const settings = context.settings;
+    const sourceCode = context.getSourceCode();
+    const pragmaNode = sourceCode.getAllComments().find((node)=>RE_JSX_ANNOTATION_REGEX.test(node.value));
+    const pragma = settings.react?.pragma ?? tools.F.pipe(tools.O.fromNullable(pragmaNode), tools.O.map((node)=>RE_JSX_ANNOTATION_REGEX.exec(node.value)), tools.O.flatMap((matches)=>tools.O.fromNullable(matches?.[1]?.split(".")[0])), tools.O.getOrElse(()=>"React"));
+    if (!RE_JS_IDENTIFIER_REGEX.test(pragma)) {
+        return tools.E.left(new Error(`React pragma ${pragma} is not a valid identifier`));
+    }
+    return tools.E.right(pragma);
+});
+
+const t=Symbol.for("@ts-pattern/matcher"),e=Symbol.for("@ts-pattern/isVariadic"),n="@ts-pattern/anonymous-select-key",r=t=>Boolean(t&&"object"==typeof t),i=e=>e&&!!e[t],s=(n,o,c)=>{if(i(n)){const e=n[t](),{matched:r,selections:i}=e.match(o);return r&&i&&Object.keys(i).forEach(t=>c(t,i[t])),r}if(r(n)){if(!r(o))return !1;if(Array.isArray(n)){if(!Array.isArray(o))return !1;let t=[],r=[],a=[];for(const s of n.keys()){const o=n[s];i(o)&&o[e]?a.push(o):a.length?r.push(o):t.push(o);}if(a.length){if(a.length>1)throw new Error("Pattern error: Using `...P.array(...)` several times in a single pattern is not allowed.");if(o.length<t.length+r.length)return !1;const e=o.slice(0,t.length),n=0===r.length?[]:o.slice(-r.length),i=o.slice(t.length,0===r.length?Infinity:-r.length);return t.every((t,n)=>s(t,e[n],c))&&r.every((t,e)=>s(t,n[e],c))&&(0===a.length||s(a[0],i,c))}return n.length===o.length&&n.every((t,e)=>s(t,o[e],c))}return Object.keys(n).every(e=>{const r=n[e];return (e in o||i(a=r)&&"optional"===a[t]().matcherType)&&s(r,o[e],c);var a;})}return Object.is(o,n)},o=e=>{var n,s,a;return r(e)?i(e)?null!=(n=null==(s=(a=e[t]()).getSelectionKeys)?void 0:s.call(a))?n:[]:Array.isArray(e)?c(e,o):c(Object.values(e),o):[]},c=(t,e)=>t.reduce((t,n)=>t.concat(e(n)),[]);function a(...t){if(1===t.length){const[e]=t;return t=>s(e,t,()=>{})}if(2===t.length){const[e,n]=t;return s(e,n,()=>{})}throw new Error(`isMatching wasn't given the right number of arguments: expected 1 or 2, received ${t.length}.`)}function u(t){return Object.assign(t,{optional:()=>l(t),and:e=>m(t,e),or:e=>y(t,e),select:e=>void 0===e?p(t):p(e,t)})}function h(t){return Object.assign((t=>Object.assign(t,{*[Symbol.iterator](){yield Object.assign(t,{[e]:!0});}}))(t),{optional:()=>h(l(t)),select:e=>h(void 0===e?p(t):p(e,t))})}function l(e){return u({[t]:()=>({match:t=>{let n={};const r=(t,e)=>{n[t]=e;};return void 0===t?(o(e).forEach(t=>r(t,void 0)),{matched:!0,selections:n}):{matched:s(e,t,r),selections:n}},getSelectionKeys:()=>o(e),matcherType:"optional"})})}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(...e){return u({[t]:()=>({match:t=>{let n={};const r=(t,e)=>{n[t]=e;};return {matched:e.every(e=>s(e,t,r)),selections:n}},getSelectionKeys:()=>c(e,o),matcherType:"and"})})}function y(...e){return u({[t]:()=>({match:t=>{let n={};const r=(t,e)=>{n[t]=e;};return c(e,o).forEach(t=>r(t,void 0)),{matched:e.some(e=>s(e,t,r)),selections:n}},getSelectionKeys:()=>c(e,o),matcherType:"or"})})}function d(e){return {[t]:()=>({match:t=>({matched:Boolean(e(t))})})}}function p(...e){const r="string"==typeof e[0]?e[0]:void 0,i=2===e.length?e[1]:"string"==typeof e[0]?void 0:e[0];return u({[t]:()=>({match:t=>{let e={[null!=r?r:n]:t};return {matched:void 0===i||s(i,t,(t,n)=>{e[t]=n;}),selections:e}},getSelectionKeys:()=>[null!=r?r:n].concat(void 0===i?[]:o(i))})})}function v(t){return "number"==typeof t}function b(t){return "string"==typeof t}function w(t){return "bigint"==typeof t}const S=u(d(function(t){return !0})),O=S,j=t=>Object.assign(u(t),{startsWith:e=>{return j(m(t,(n=e,d(t=>b(t)&&t.startsWith(n)))));var n;},endsWith:e=>{return j(m(t,(n=e,d(t=>b(t)&&t.endsWith(n)))));var n;},minLength:e=>j(m(t,(t=>d(e=>b(e)&&e.length>=t))(e))),maxLength:e=>j(m(t,(t=>d(e=>b(e)&&e.length<=t))(e))),includes:e=>{return j(m(t,(n=e,d(t=>b(t)&&t.includes(n)))));var n;},regex:e=>{return j(m(t,(n=e,d(t=>b(t)&&Boolean(t.match(n))))));var n;}}),E=j(d(b)),K=t=>Object.assign(u(t),{between:(e,n)=>K(m(t,((t,e)=>d(n=>v(n)&&t<=n&&e>=n))(e,n))),lt:e=>K(m(t,(t=>d(e=>v(e)&&e<t))(e))),gt:e=>K(m(t,(t=>d(e=>v(e)&&e>t))(e))),lte:e=>K(m(t,(t=>d(e=>v(e)&&e<=t))(e))),gte:e=>K(m(t,(t=>d(e=>v(e)&&e>=t))(e))),int:()=>K(m(t,d(t=>v(t)&&Number.isInteger(t)))),finite:()=>K(m(t,d(t=>v(t)&&Number.isFinite(t)))),positive:()=>K(m(t,d(t=>v(t)&&t>0))),negative:()=>K(m(t,d(t=>v(t)&&t<0)))}),A=K(d(v)),x=t=>Object.assign(u(t),{between:(e,n)=>x(m(t,((t,e)=>d(n=>w(n)&&t<=n&&e>=n))(e,n))),lt:e=>x(m(t,(t=>d(e=>w(e)&&e<t))(e))),gt:e=>x(m(t,(t=>d(e=>w(e)&&e>t))(e))),lte:e=>x(m(t,(t=>d(e=>w(e)&&e<=t))(e))),gte:e=>x(m(t,(t=>d(e=>w(e)&&e>=t))(e))),positive:()=>x(m(t,d(t=>w(t)&&t>0))),negative:()=>x(m(t,d(t=>w(t)&&t<0)))}),P=x(d(w)),T=u(d(function(t){return "boolean"==typeof t})),k=u(d(function(t){return "symbol"==typeof t})),B=u(d(function(t){return null==t}));var _={__proto__:null,matcher:t,optional:l,array:function(...e){return h({[t]:()=>({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(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(n,t,i)),selections:r}},getSelectionKeys:()=>0===e.length?[]:o(e[0])})})},set:function(...e){return u({[t]:()=>({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(i,t,r)),selections:n}},getSelectionKeys:()=>0===e.length?[]:o(e[0])})})},map:function(...e){return u({[t]:()=>({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(o,e,r),i=s(c,t,r);return n&&i}),selections:n}},getSelectionKeys:()=>0===e.length?[]:[...o(e[0]),...o(e[1])]})})},intersection:m,union:y,not:function(e){return u({[t]:()=>({match:t=>({matched:!s(e,t,()=>{})}),getSelectionKeys:()=>[],matcherType:"not"})})},when:d,select:p,any:S,_:O,string:E,number:A,bigint:P,boolean:T,symbol:k,nullish:B,instanceOf:function(t){return u(d(function(t){return e=>e instanceof t}(t)))},shape:function(t){return u(d(a(t)))}};const W={matched:!1,value:void 0};function N(t){return new $(t,W)}class ${constructor(t,e){this.input=void 0,this.state=void 0,this.input=t,this.state=e;}with(...t){if(this.state.matched)return this;const e=t[t.length-1],r=[t[0]];let i;3===t.length&&"function"==typeof t[1]?(r.push(t[0]),i=t[1]):t.length>2&&r.push(...t.slice(1,t.length-1));let o=!1,c={};const a=(t,e)=>{o=!0,c[t]=e;},u=!r.some(t=>s(t,this.input,a))||i&&!Boolean(i(this.input))?W:{matched:!0,value:e(o?n in c?c[n]:c:this.input,this.input)};return new $(this.input,u)}when(t,e){if(this.state.matched)return this;const n=Boolean(t(this.input));return new $(this.input,n?{matched:!0,value:e(this.input,this.input)}:W)}otherwise(t){return this.state.matched?this.state.value:t(this.input)}exhaustive(){return this.run()}run(){if(this.state.matched)return this.state.value;let t;try{t=JSON.stringify(this.input);}catch(e){t=this.input;}throw new Error(`Pattern matching error: no pattern matches value ${t}`)}returnType(){return this}}
+
+function isDestructuredFromPragma(variableName, context) {
+    const maybePragma = getPragmaFromContext(context);
+    const variables = ast.getVariablesUpToGlobal(context.getScope());
+    if (tools.E.isLeft(maybePragma)) {
+        return false;
+    }
+    const pragma = maybePragma.right;
+    const maybeLatestDef = tools.F.pipe(ast.findVariableByName(variableName)(variables), tools.O.flatMapNullable((variable)=>variable.defs.at(-1)));
+    if (tools.O.isNone(maybeLatestDef)) {
+        return false;
+    }
+    const latestDef = maybeLatestDef.value;
+    const { node, parent } = latestDef;
+    if (node.type === ast.NodeType.VariableDeclarator && node.init) {
+        const { init } = node;
+        // check for: `variable = pragma.variable`
+        if (a({
+            type: "MemberExpression",
+            object: {
+                type: "Identifier",
+                name: pragma
+            }
+        }, init)) {
+            return true;
+        }
+        // check for: `{ variable } = pragma`
+        if (a({
+            type: "Identifier",
+            name: pragma
+        }, init)) {
+            return true;
+        }
+        // check if from a require call: `require("react")`
+        const maybeRequireExpression = N(init).with({
+            type: ast.NodeType.CallExpression
+        }, (exp)=>tools.O.some(exp)).with({
+            type: ast.NodeType.MemberExpression,
+            object: {
+                type: ast.NodeType.CallExpression
+            }
+        }, ({ object })=>tools.O.some(object)).otherwise(tools.O.none);
+        if (tools.O.isNone(maybeRequireExpression)) {
+            return false;
+        }
+        const requireExpression = maybeRequireExpression.value;
+        if (requireExpression.callee.type !== ast.NodeType.Identifier) {
+            return false;
+        }
+        const calleeName = requireExpression.callee.name;
+        const [firstArg] = requireExpression.arguments;
+        if (calleeName !== "require" || firstArg?.type !== ast.NodeType.Literal) {
+            return false;
+        }
+        return firstArg.value === pragma.toLowerCase();
+    }
+    // latest definition is an import declaration: import { variable } from 'react'
+    return a({
+        type: "ImportDeclaration",
+        source: {
+            value: pragma.toLowerCase()
+        }
+    }, parent);
+}
+
+/**
+ * Checks if the given node is a call expression to the given function or method of the pragma
+ * @param name The name of the function or method to check
+ * @returns A predicate that checks if the given node is a call expression to the given function or method
+ */ const isCallFromPragma = (name)=>(node, context)=>{
+        if (node.type !== ast.NodeType.CallExpression || !("callee" in node)) {
+            return false;
+        }
+        const maybePragma = getPragmaFromContext(context);
+        if (tools.E.isLeft(maybePragma)) {
+            return false;
+        }
+        const pragma = maybePragma.right;
+        return N(node.callee).with({
+            type: ast.NodeType.MemberExpression,
+            object: {
+                name: pragma
+            },
+            property: {
+                name
+            }
+        }, tools.F.constTrue).with({
+            name
+        }, ({ name })=>isDestructuredFromPragma(name, context)).otherwise(tools.F.constFalse);
+    };
+
+/**
+ * Checks if the given node is a call expression to `React.createElement`
+ * @param node The AST node to check
+ * @param context The rule context
+ * @returns `true` if the node is a call expression to `createElement`
+ */ const isCreateElementCall = isCallFromPragma("createElement");
+/**
+ * Checks if the given node is a call expression to `React.cloneElement`
+ * @param node The AST node to check
+ * @param context The rule context
+ * @returns `true` if the node is a call expression to `cloneElement`
+ */ const isCloneElementCall = isCallFromPragma("cloneElement");
+
+function isChildrenOfCreateElement(node, context) {
+    const maybeCallExpression = node.parent;
+    if (!maybeCallExpression || !isCreateElementCall(maybeCallExpression, context)) {
+        return false;
+    }
+    return maybeCallExpression.arguments.slice(2).some((child)=>child === node);
+}
+
+/**
+ * Determines whether inside createElement's props.
+ * @param node The AST node to check
+ * @param context The rule context
+ * @returns `true` if the node is inside createElement's props
+ */ function isInsideCreateElementProps(node, context) {
+    const parentCreateElement = ast.traverseUp(node, (n)=>isCreateElementCall(n, context));
+    if (parentCreateElement?.type !== ast.NodeType.CallExpression) {
+        return false;
+    }
+    return parentCreateElement.arguments.at(1) === ast.traverseUp(node, ast.is(ast.NodeType.ObjectExpression));
+}
+
+function resolveMemberExpressions(object, property) {
+    if (object.type === types.AST_NODE_TYPES.JSXMemberExpression) {
+        return `${resolveMemberExpressions(object.object, object.property)}.${property.name}`;
+    }
+    if (object.type === types.AST_NODE_TYPES.JSXNamespacedName) {
+        return `${object.namespace.name}:${object.name.name}.${property.name}`;
+    }
+    return `${object.name}.${property.name}`;
+}
+/**
+ * Returns the tag name associated with a JSXOpeningElement.
+ * @param node The visited JSXOpeningElement node object.
+ * @returns The element's tag name.
+ */ function elementType(node) {
+    if (node.type === types.AST_NODE_TYPES.JSXOpeningFragment) {
+        return "<>";
+    }
+    const { name } = node;
+    if (name.type === types.AST_NODE_TYPES.JSXMemberExpression) {
+        const { object, property } = name;
+        return resolveMemberExpressions(object, property);
+    }
+    if (name.type === types.AST_NODE_TYPES.JSXNamespacedName) {
+        return `${name.namespace.name}:${name.name.name}`;
+    }
+    return name.name;
+}
+
+const hdlAnimation = [
+    "onAnimationStart",
+    "onAnimationEnd",
+    "onAnimationIteration"
+];
+const hdlClipboard = [
+    "onCopy",
+    "onCut",
+    "onPaste"
+];
+const hdlComposition = [
+    "onCompositionEnd",
+    "onCompositionStart",
+    "onCompositionUpdate"
+];
+const hdlFocus = [
+    "onFocus",
+    "onBlur"
+];
+const hdlForm = [
+    "onChange",
+    "onInput",
+    "onSubmit"
+];
+const hdlImage = [
+    "onLoad",
+    "onError"
+];
+const hdlKeyboard = [
+    "onKeyDown",
+    "onKeyPress",
+    "onKeyUp"
+];
+const hdlMedia = [
+    "onAbort",
+    "onCanPlay",
+    "onCanPlayThrough",
+    "onDurationChange",
+    "onEmptied",
+    "onEncrypted",
+    "onEnded",
+    "onError",
+    "onLoadedData",
+    "onLoadedMetadata",
+    "onLoadStart",
+    "onPause",
+    "onPlay",
+    "onPlaying",
+    "onProgress",
+    "onRateChange",
+    "onSeeked",
+    "onSeeking",
+    "onStalled",
+    "onSuspend",
+    "onTimeUpdate",
+    "onVolumeChange",
+    "onWaiting"
+];
+const hdlMouse = [
+    "onClick",
+    "onContextMenu",
+    "onDblClick",
+    "onDoubleClick",
+    "onDrag",
+    "onDragEnd",
+    "onDragEnter",
+    "onDragExit",
+    "onDragLeave",
+    "onDragOver",
+    "onDragStart",
+    "onDrop",
+    "onMouseDown",
+    "onMouseEnter",
+    "onMouseLeave",
+    "onMouseMove",
+    "onMouseOut",
+    "onMouseOver",
+    "onMouseUp"
+];
+const hdlSelection = [
+    "onSelect"
+];
+const hdlTouch = [
+    "onTouchCancel",
+    "onTouchEnd",
+    "onTouchMove",
+    "onTouchStart"
+];
+const hdlTransition = [
+    "onTransitionEnd"
+];
+const hdlScroll = [
+    "onScroll"
+];
+const hdlWheel = [
+    "onWheel"
+];
+[
+    ...hdlAnimation,
+    ...hdlClipboard,
+    ...hdlComposition,
+    ...hdlFocus,
+    ...hdlForm,
+    ...hdlImage,
+    ...hdlKeyboard,
+    ...hdlMedia,
+    ...hdlMouse,
+    ...hdlSelection,
+    ...hdlTouch,
+    ...hdlTransition,
+    ...hdlScroll,
+    ...hdlWheel
+];
+
+/**
+ * Tests if a value is a `string`.
+ *
+ * @param input - The value to test.
+ *
+ * @example
+ * import { isString } from "effect/Predicate"
+ *
+ * assert.deepStrictEqual(isString("a"), true)
+ *
+ * assert.deepStrictEqual(isString(1), false)
+ *
+ * @category guards
+ * @since 2.0.0
+ */
+const isString = input => typeof input === "string";
+
+const defaultJSXValueCheckOptions = {
+    ignoreNull: false,
+    strict: false
+};
+/**
+ * Check if a node is a JSX value
+ * @param node The AST node to check
+ * @param context The rule context
+ * @param options The `JSXValueCheckOptions` to use
+ * @returns boolean
+ */ function isJSXValue(node, context, options = defaultJSXValueCheckOptions) {
+    if (!node) {
+        return false;
+    }
+    // TODO: implement strict mode
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    const { ignoreNull = false, strict = false } = options;
+    return N(node.type).with(ast.NodeType.JSXElement, tools.F.constTrue).with(ast.NodeType.JSXFragment, tools.F.constTrue).with(ast.NodeType.Literal, ()=>{
+        if (!("value" in node) || ignoreNull) {
+            return false;
+        }
+        return node.value === null;
+    }).with(ast.NodeType.ConditionalExpression, ()=>{
+        if (!("consequent" in node)) {
+            return false;
+        }
+        const leftHasJSX = N(node.consequent).with(_.array(), (n)=>n.some((n)=>isJSXValue(n, context, options))).with(_.any, (n)=>isJSXValue(n, context, options)).exhaustive();
+        if (leftHasJSX) {
+            return true;
+        }
+        return "alternate" in node && isJSXValue(node.alternate, context, options);
+    }).with(ast.NodeType.LogicalExpression, ()=>{
+        if (!("left" in node)) {
+            return false;
+        }
+        return isJSXValue(node.left, context, options) || isJSXValue(node.right, context, options);
+    }).with(ast.NodeType.SequenceExpression, ()=>{
+        if (!("expressions" in node)) {
+            return false;
+        }
+        const exp = node.expressions.at(-1);
+        return isJSXValue(exp, context, options);
+    }).with(ast.NodeType.CallExpression, ()=>isCreateElementCall(node, context)).with(ast.NodeType.Identifier, ()=>{
+        if (!("name" in node)) {
+            return false;
+        }
+        if (ast.isJSXTagNameExpression(node)) {
+            return true;
+        }
+        if (!isString(node.name) && node.name.type !== ast.NodeType.Identifier) {
+            return ast.isJSXTagNameExpression(node.name);
+        }
+        const name = N(node.name).with(_.string, tools.F.identity).with({
+            type: ast.NodeType.Identifier
+        }, (n)=>n.name).exhaustive();
+        const variable = ast.findVariableByNameUpToGlobal(name, context.getScope());
+        return tools.F.pipe(variable, tools.O.flatMap(ast.getVariableNthDefNodeInit(0)), tools.O.map(ast.isOneOf([
+            ast.NodeType.JSXElement,
+            ast.NodeType.JSXFragment
+        ])), tools.O.getOrElse(tools.F.constFalse));
+    }).otherwise(tools.F.constFalse);
+}
+
+/**
+ * Check if function is returning JSX
+ * @param node The return statement node to check
+ * @param context The rule context
+ * @param options The JSX value check options
+ * @returns boolean
+ */ function isFunctionReturningJSXValue(node, context, options) {
+    if (node.body.type !== ast.NodeType.BlockStatement) {
+        return isJSXValue(node.body, context, options);
+    }
+    const statements = ast.getNestedReturnStatements(node.body);
+    return statements.some((statement)=>isJSXValue(statement.argument, context, options));
+}
+
+/**
+ * Check if the given prop name is present in the given attributes
+ * @param attributes The attributes to search in
+ * @param propName The prop name to search for
+ * @param context The rule context
+ * @returns `true` if the given prop name is present in the given properties
+ */ function hasProp(attributes, propName, context) {
+    return tools.O.isSome(findPropInAttributes(attributes, context)(propName));
+}
+/**
+ * Check if any of the given prop names are present in the given attributes
+ * @param attributes The attributes to search in
+ * @param propNames The prop names to search for
+ * @param context The rule context
+ * @returns `true` if any of the given prop names are present in the given attributes
+ */ function hasAnyProp(attributes, propNames, context) {
+    return propNames.some((propName)=>hasProp(attributes, propName, context));
+}
+/**
+ * Check if all of the given prop names are present in the given attributes
+ * @param attributes The attributes to search in
+ * @param propNames The prop names to search for
+ * @param context The rule context
+ * @returns `true` if all of the given prop names are present in the given attributes
+ */ function hasEveryProp(attributes, propNames, context) {
+    return propNames.every((propName)=>hasProp(attributes, propName, context));
+}
+/**
+ * Get the name of a JSX attribute
+ * @param node The JSX attribute node
+ * @returns string
+ */ function getPropName(node) {
+    return N(node.name).when(ast.is(ast.NodeType.JSXIdentifier), (n)=>n.name).when(ast.is(ast.NodeType.JSXNamespacedName), (n)=>n.name.name).exhaustive();
+}
+/**
+ * Get the name of a JSX attribute with namespace
+ * @param node The JSX attribute node
+ * @returns string
+ */ function getPropNameWithNamespace(node) {
+    return N(node.name).when(ast.is(ast.NodeType.JSXIdentifier), (n)=>n.name).when(ast.is(ast.NodeType.JSXNamespacedName), (n)=>`${n.namespace.name}:${n.name.name}`).exhaustive();
+}
+/**
+ * Traverses up prop node
+ * @param node The AST node to start traversing from
+ * @param predicate The predicate to check each node
+ * @returns prop node if found
+ */ function traverseUpProp(node, predicate = tools.F.constTrue) {
+    const matcher = (node)=>{
+        return node.type === ast.NodeType.JSXAttribute && predicate(node);
+    };
+    return tools.O.fromNullable(ast.traverseUpGuard(node, matcher));
+}
+/**
+ * Checks if the node is inside a prop's value
+ * @param node The AST node to check
+ * @returns `true` if the node is inside a prop's value
+ */ function isInsidePropValue(node) {
+    if (ast.isStringLiteral(node)) {
+        return node.parent.type === ast.NodeType.JSXAttribute;
+    }
+    return tools.O.isSome(traverseUpProp(node, (n)=>n.value?.type === ast.NodeType.JSXExpressionContainer));
+}
+/**
+ * @param properties The properties to search in
+ * @param context The rule context
+ * @param seenProps The properties that have already been seen
+ * @returns A function that searches for a property in the given properties
+ */ function findPropInProperties(properties, context, seenProps = []) {
+    /**
+   * Search for a property in the given properties
+   * @param propName The name of the property to search for
+   * @returns The property if found
+   */ return (propName)=>{
+        return tools.O.fromNullable(properties.find((prop)=>{
+            if (prop.type === ast.NodeType.Property) {
+                return "name" in prop.key && prop.key.name === propName;
+            }
+            if (prop.type === ast.NodeType.SpreadElement) {
+                if (!("argument" in prop && "name" in prop.argument)) {
+                    return false;
+                }
+                const { name } = prop.argument;
+                const maybeFirstDefNodeInit = tools.F.pipe(ast.findVariableByNameUpToGlobal(name, context.getScope()), tools.O.flatMap(ast.getVariableNthDefNodeInit(0)));
+                if (tools.O.isNone(maybeFirstDefNodeInit)) {
+                    return false;
+                }
+                const firstDefNodeInit = maybeFirstDefNodeInit.value;
+                if (firstDefNodeInit.type !== ast.NodeType.ObjectExpression) {
+                    return false;
+                }
+                if (seenProps.includes(name)) {
+                    return false;
+                }
+                return tools.O.isSome(findPropInProperties(firstDefNodeInit.properties, context, [
+                    ...seenProps,
+                    name
+                ])(propName));
+            }
+            return false;
+        }));
+    };
+}
+/**
+ * @param attributes The attributes to search in
+ * @param context The rule context
+ * @returns A function that searches for a property in the given attributes
+ */ function findPropInAttributes(attributes, context) {
+    /**
+   * Search for a property in the given attributes
+   * @param propName The name of the property to search for
+   * @returns The property if found
+   */ return (propName)=>{
+        return tools.O.fromNullable(attributes.find((attr)=>{
+            return N(attr).when(ast.is(ast.NodeType.JSXAttribute), (attr)=>getPropName(attr) === propName).when(ast.is(ast.NodeType.JSXSpreadAttribute), (attr)=>{
+                if (!("argument" in attr && "name" in attr.argument)) {
+                    return false;
+                }
+                const { name } = attr.argument;
+                const maybeFirstDefNodeInit = tools.F.pipe(ast.findVariableByNameUpToGlobal(name, context.getScope()), tools.O.flatMap(ast.getVariableNthDefNodeInit(0)));
+                if (tools.O.isNone(maybeFirstDefNodeInit)) {
+                    return false;
+                }
+                if (!("properties" in maybeFirstDefNodeInit.value)) {
+                    return false;
+                }
+                return tools.O.isSome(findPropInProperties(maybeFirstDefNodeInit.value.properties, context)(propName));
+            }).otherwise(tools.F.constFalse);
+        }));
+    };
+}
+
+/**
+ * Check if a node is a Literal or JSXText
+ * @param node The AST node to check
+ * @returns boolean `true` if the node is a Literal or JSXText
+ */ const isLiteral = ast.isOneOf([
+    ast.NodeType.Literal,
+    ast.NodeType.JSXText
+]);
+/**
+ * Check if a Literal or JSXText node is whitespace
+ * @param node The AST node to check
+ * @returns boolean `true` if the node is whitespace
+ */ function isWhiteSpace(node) {
+    return isString(node.value) && node.value.trim() === "";
+}
+/**
+ * Check if a Literal or JSXText node is a line break
+ * @param node The AST node to check
+ * @returns boolean
+ */ function isLineBreak(node) {
+    return isLiteral(node) && isWhiteSpace(node) && ast.isMultiLine(node);
+}
+
+exports.defaultJSXValueCheckOptions = defaultJSXValueCheckOptions;
+exports.elementType = elementType;
+exports.findPropInAttributes = findPropInAttributes;
+exports.findPropInProperties = findPropInProperties;
+exports.getFragmentFromContext = getFragmentFromContext;
+exports.getPragmaFromContext = getPragmaFromContext;
+exports.getPropName = getPropName;
+exports.getPropNameWithNamespace = getPropNameWithNamespace;
+exports.hasAnyProp = hasAnyProp;
+exports.hasChildren = hasChildren;
+exports.hasEveryProp = hasEveryProp;
+exports.hasProp = hasProp;
+exports.hdlAnimation = hdlAnimation;
+exports.hdlClipboard = hdlClipboard;
+exports.hdlComposition = hdlComposition;
+exports.hdlFocus = hdlFocus;
+exports.hdlForm = hdlForm;
+exports.hdlImage = hdlImage;
+exports.hdlKeyboard = hdlKeyboard;
+exports.hdlMedia = hdlMedia;
+exports.hdlMouse = hdlMouse;
+exports.hdlScroll = hdlScroll;
+exports.hdlSelection = hdlSelection;
+exports.hdlTouch = hdlTouch;
+exports.hdlTransition = hdlTransition;
+exports.hdlWheel = hdlWheel;
+exports.isCallFromPragma = isCallFromPragma;
+exports.isChildrenOfCreateElement = isChildrenOfCreateElement;
+exports.isCloneElementCall = isCloneElementCall;
+exports.isCreateElementCall = isCreateElementCall;
+exports.isDestructuredFromPragma = isDestructuredFromPragma;
+exports.isFunctionReturningJSXValue = isFunctionReturningJSXValue;
+exports.isInsideCreateElementProps = isInsideCreateElementProps;
+exports.isInsidePropValue = isInsidePropValue;
+exports.isJSXValue = isJSXValue;
+exports.isLineBreak = isLineBreak;
+exports.isLiteral = isLiteral;
+exports.isWhiteSpace = isWhiteSpace;
+exports.traverseUpProp = traverseUpProp;