@eslint-react/ast 1.20.2-next.1 → 1.20.2-next.3

package/dist/index.d.mts

@@ -1,4 +1,4 @@
-import { O } from '@eslint-react/tools';
+import { O } from '@eslint-react/eff';
 import { TSESTree as TSESTree$1, AST_NODE_TYPES as AST_NODE_TYPES$1 } from '@typescript-eslint/types';
 import { TSESTree } from '@typescript-eslint/utils';
 import { SyntaxKind } from 'typescript';

package/dist/index.d.ts

@@ -1,4 +1,4 @@
-import { O } from '@eslint-react/tools';
+import { O } from '@eslint-react/eff';
 import { TSESTree as TSESTree$1, AST_NODE_TYPES as AST_NODE_TYPES$1 } from '@typescript-eslint/types';
 import { TSESTree } from '@typescript-eslint/utils';
 import { SyntaxKind } from 'typescript';

package/dist/index.js

@@ -1,25 +1,26 @@
 'use strict';
 
-var tools = require('@eslint-react/tools');
+var eff = require('@eslint-react/eff');
 var types = require('@typescript-eslint/types');
 var utils = require('@typescript-eslint/utils');
 var tsPattern = require('ts-pattern');
 var typescriptEstree = require('@typescript-eslint/typescript-estree');
+var types$1 = require('@eslint-react/types');
 var stringTs = require('string-ts');
 
 // src/function-init-path.ts
 function getFunctionInitPath(node) {
   const { parent } = node;
-  if (node.type === types.AST_NODE_TYPES.FunctionDeclaration) return tools.O.some([node]);
+  if (node.type === types.AST_NODE_TYPES.FunctionDeclaration) return eff.O.some([node]);
   if (parent.type === types.AST_NODE_TYPES.VariableDeclarator) {
-    return tools.O.some([
+    return eff.O.some([
       parent.parent,
       parent,
       node
     ]);
   }
   if (parent.type === types.AST_NODE_TYPES.CallExpression && parent.parent.type === types.AST_NODE_TYPES.VariableDeclarator) {
-    return tools.O.some([
+    return eff.O.some([
       parent.parent.parent,
       parent.parent,
       parent,
@@ -27,7 +28,7 @@ function getFunctionInitPath(node) {
     ]);
   }
   if (parent.type === types.AST_NODE_TYPES.CallExpression && parent.parent.type === types.AST_NODE_TYPES.CallExpression && parent.parent.parent.type === types.AST_NODE_TYPES.VariableDeclarator) {
-    return tools.O.some([
+    return eff.O.some([
       parent.parent.parent.parent,
       parent.parent.parent,
       parent.parent,
@@ -36,7 +37,7 @@ function getFunctionInitPath(node) {
     ]);
   }
   if (parent.type === types.AST_NODE_TYPES.Property && parent.parent.type === types.AST_NODE_TYPES.ObjectExpression && parent.parent.parent.type === types.AST_NODE_TYPES.VariableDeclarator) {
-    return tools.O.some([
+    return eff.O.some([
       parent.parent.parent.parent,
       parent.parent.parent,
       parent.parent,
@@ -45,7 +46,7 @@ function getFunctionInitPath(node) {
     ]);
   }
   if (parent.type === types.AST_NODE_TYPES.MethodDefinition && parent.parent.parent.type === types.AST_NODE_TYPES.ClassDeclaration) {
-    return tools.O.some([
+    return eff.O.some([
       parent.parent.parent,
       parent.parent,
       parent,
@@ -53,21 +54,21 @@ function getFunctionInitPath(node) {
     ]);
   }
   if (parent.type === types.AST_NODE_TYPES.PropertyDefinition && parent.parent.parent.type === types.AST_NODE_TYPES.ClassDeclaration) {
-    return tools.O.some([
+    return eff.O.some([
       parent.parent.parent,
       parent.parent,
       parent,
       node
     ]);
   }
-  return tools.O.none();
+  return eff.O.none();
 }
 function hasCallInFunctionInitPath(callName) {
   return (initPath) => {
-    return tools.F.pipe(
+    return eff.F.pipe(
       initPath,
-      tools.O.filter((p) => p.length > 0),
-      tools.O.exists((nodes) => {
+      eff.O.filter((p) => p.length > 0),
+      eff.O.exists((nodes) => {
         return nodes.some(
           // TODO: Re-evaluate dot notation callName
           // callName.includes(".")
@@ -96,11 +97,11 @@ function hasCallInFunctionInitPath(callName) {
   };
 }
 function getClassIdentifier(node) {
-  if (node.id) return tools.O.fromNullable(node.id);
+  if (node.id) return eff.O.fromNullable(node.id);
   if (node.parent.type === types.AST_NODE_TYPES.VariableDeclarator && node.parent.id.type === types.AST_NODE_TYPES.Identifier) {
-    return tools.O.fromNullable(node.parent.id);
+    return eff.O.fromNullable(node.parent.id);
   }
-  return tools.O.none();
+  return eff.O.none();
 }
 var is = utils.ASTUtils.isNodeOfType;
 var isOneOf = utils.ASTUtils.isNodeOfTypes;
@@ -128,14 +129,14 @@ var isLoop = isOneOf([
   types.AST_NODE_TYPES.ForStatement,
   types.AST_NODE_TYPES.WhileStatement
 ]);
-var isControlFlow = tools.or(
+var isControlFlow = eff.or(
   isLoop,
   isOneOf([
     types.AST_NODE_TYPES.IfStatement,
     types.AST_NODE_TYPES.SwitchStatement
   ])
 );
-var isConditional = tools.or(
+var isConditional = eff.or(
   isControlFlow,
   isOneOf([
     types.AST_NODE_TYPES.LogicalExpression,
@@ -235,33 +236,33 @@ function getFunctionIdentifier(node) {
   switch (true) {
     // function MaybeComponent() {}
     case ("id" in node && !!node.id):
-      return tools.O.some(node.id);
+      return eff.O.some(node.id);
     // const whatever = function MaybeComponent() {};
     case (node.parent.type === types.AST_NODE_TYPES.VariableDeclarator && node.parent.init === node && node.parent.id.type === types.AST_NODE_TYPES.Identifier):
-      return tools.O.some(node.parent.id);
+      return eff.O.some(node.parent.id);
     // MaybeComponent = () => {};
     case (node.parent.type === types.AST_NODE_TYPES.AssignmentExpression && node.parent.right === node && node.parent.operator === "=" && node.parent.left.type === types.AST_NODE_TYPES.Identifier):
-      return tools.O.some(node.parent.left);
+      return eff.O.some(node.parent.left);
     // {MaybeComponent: () => {}}
     // {MaybeComponent() {}}
     case (node.parent.type === types.AST_NODE_TYPES.Property && node.parent.value === node && !node.parent.computed && node.parent.key.type === types.AST_NODE_TYPES.Identifier):
-      return tools.O.some(node.parent.key);
+      return eff.O.some(node.parent.key);
     // class {MaybeComponent = () => {}}
     // class {MaybeComponent() {}}
     case (isOneOf([types.AST_NODE_TYPES.MethodDefinition, types.AST_NODE_TYPES.PropertyDefinition])(node.parent) && node.parent.value === node && node.parent.key.type === types.AST_NODE_TYPES.Identifier):
-      return tools.O.some(node.parent.key);
+      return eff.O.some(node.parent.key);
     // Follow spec convention for `IsAnonymousFunctionDefinition()` usage.
     //
     // const {MaybeComponent = () => {}} = {};
     // ({MaybeComponent = () => {}} = {});
     case (node.parent.type === types.AST_NODE_TYPES.AssignmentPattern && node.parent.right === node && node.parent.left.type === types.AST_NODE_TYPES.Identifier):
-      return tools.O.some(node.parent.left);
+      return eff.O.some(node.parent.left);
     // const MaybeComponent = (() => {}) as FunctionComponent;
     // const MaybeComponent = (() => {}) satisfies FunctionComponent;
     case isOneOf([types.AST_NODE_TYPES.TSAsExpression, types.AST_NODE_TYPES.TSSatisfiesExpression])(node.parent):
       return getFunctionIdentifier(node.parent);
   }
-  return tools.O.none();
+  return eff.O.none();
 }
 function getIdentifiersFromBinaryExpression(side) {
   if (side.type === types.AST_NODE_TYPES.Identifier) return [side];
@@ -410,20 +411,20 @@ function getNestedIdentifiers(node) {
   return identifiers;
 }
 var getNestedNewExpressions = getNestedExpressionsOfType(typescriptEstree.AST_NODE_TYPES.NewExpression);
-var traverseUpGuard = tools.F.dual(2, (node, predicate) => {
+var traverseUpGuard = eff.F.dual(2, (node, predicate) => {
   const { parent } = node;
-  if (!parent || parent.type === types.AST_NODE_TYPES.Program) return tools.O.none();
-  return predicate(parent) ? tools.O.some(parent) : traverseUpGuard(parent, predicate);
+  if (!parent || parent.type === types.AST_NODE_TYPES.Program) return eff.O.none();
+  return predicate(parent) ? eff.O.some(parent) : traverseUpGuard(parent, predicate);
 });
 
 // src/get-nested-return-statements.ts
 function getNestedReturnStatements(node) {
   const returnStatements = [];
-  const functionNode = isFunction(node) ? node : tools.O.getOrNull(traverseUpGuard(node, isFunction));
+  const functionNode = isFunction(node) ? node : eff.O.getOrNull(traverseUpGuard(node, isFunction));
   typescriptEstree.simpleTraverse(node, {
     enter(node2) {
       if (node2.type !== types.AST_NODE_TYPES.ReturnStatement) return;
-      const parentFunction = tools.O.getOrNull(traverseUpGuard(node2, isFunction));
+      const parentFunction = eff.O.getOrNull(traverseUpGuard(node2, isFunction));
       if (parentFunction !== functionNode) return;
       returnStatements.push(node2);
     }
@@ -433,11 +434,11 @@ function getNestedReturnStatements(node) {
 function getTopLevelIdentifier(node) {
   switch (node.type) {
     case types.AST_NODE_TYPES.Identifier:
-      return tools.O.some(node);
+      return eff.O.some(node);
     case types.AST_NODE_TYPES.MemberExpression:
       return getTopLevelIdentifier(node.object);
     default:
-      return tools.O.none();
+      return eff.O.none();
   }
 }
 function isEmptyFunction(node) {
@@ -474,7 +475,7 @@ var isFunctionOfObjectMethod = tsPattern.isMatching({
   }
 });
 function isKeyLiteralLike(node, property) {
-  return tsPattern.match(property).with({ type: types.AST_NODE_TYPES.Literal }, tools.F.constTrue).with({ type: types.AST_NODE_TYPES.TemplateLiteral, expressions: [] }, tools.F.constTrue).with({ type: types.AST_NODE_TYPES.Identifier }, () => !node.computed).otherwise(tools.F.constFalse);
+  return tsPattern.match(property).with({ type: types.AST_NODE_TYPES.Literal }, eff.F.constTrue).with({ type: types.AST_NODE_TYPES.TemplateLiteral, expressions: [] }, eff.F.constTrue).with({ type: types.AST_NODE_TYPES.Identifier }, () => !node.computed).otherwise(eff.F.constFalse);
 }
 function isMapCallLoose(node) {
   if (node.type !== types.AST_NODE_TYPES.CallExpression) return false;
@@ -488,7 +489,7 @@ function isMapCallLoose(node) {
 function isMultiLine(node) {
   return node.loc.start.line !== node.loc.end.line;
 }
-var isNodeEqual = tools.F.dual(2, (a, b) => {
+var isNodeEqual = eff.F.dual(2, (a, b) => {
   if (a.type !== b.type) return false;
   if (a.type === types.AST_NODE_TYPES.ThisExpression && b.type === types.AST_NODE_TYPES.ThisExpression) return true;
   if (a.type === types.AST_NODE_TYPES.Literal && b.type === types.AST_NODE_TYPES.Literal) return a.value === b.value;
@@ -497,8 +498,8 @@ var isNodeEqual = tools.F.dual(2, (a, b) => {
   }
   if (a.type === types.AST_NODE_TYPES.TemplateLiteral && b.type === types.AST_NODE_TYPES.TemplateLiteral) {
     if (a.quasis.length !== b.quasis.length || a.expressions.length !== b.expressions.length) return false;
-    if (!tools.zip(a.quasis, b.quasis).every(([a2, b2]) => isNodeEqual(a2, b2))) return false;
-    if (!tools.zip(a.expressions, b.expressions).every(([a2, b2]) => isNodeEqual(a2, b2))) return false;
+    if (!types$1.zip(a.quasis, b.quasis).every(([a2, b2]) => isNodeEqual(a2, b2))) return false;
+    if (!types$1.zip(a.expressions, b.expressions).every(([a2, b2]) => isNodeEqual(a2, b2))) return false;
     return true;
   }
   if (a.type === types.AST_NODE_TYPES.Identifier && b.type === types.AST_NODE_TYPES.Identifier) return a.name === b.name;
@@ -514,7 +515,7 @@ function isRegExpLiteral(node) {
   return node.type === types.AST_NODE_TYPES.Literal && "regex" in node;
 }
 function isStringLiteral(node) {
-  return node.type === types.AST_NODE_TYPES.Literal && tools.isString(node.value);
+  return node.type === types.AST_NODE_TYPES.Literal && eff.isString(node.value);
 }
 function isThisExpression(node) {
   if (node.type === types.AST_NODE_TYPES.TSAsExpression) {
@@ -552,10 +553,10 @@ function toReadableNodeType(node) {
   if (isJSX(node)) return `JSX ${stringTs.toLowerCase(stringTs.delimiterCase(stringTs.replace(node.type, "JSX", ""), " "))}`;
   return stringTs.toLowerCase(stringTs.delimiterCase(node.type, " "));
 }
-var traverseUp = tools.F.dual(2, (node, predicate) => {
+var traverseUp = eff.F.dual(2, (node, predicate) => {
   const { parent } = node;
-  if (!parent || parent.type === types.AST_NODE_TYPES.Program) return tools.O.none();
-  return predicate(parent) ? tools.O.some(parent) : traverseUp(parent, predicate);
+  if (!parent || parent.type === types.AST_NODE_TYPES.Program) return eff.O.none();
+  return predicate(parent) ? eff.O.some(parent) : traverseUp(parent, predicate);
 });
 
 exports.getClassIdentifier = getClassIdentifier;

package/dist/index.mjs

@@ -1,8 +1,9 @@
-import { or, F, O, zip, isString } from '@eslint-react/tools';
+import { or, F, O, isString } from '@eslint-react/eff';
 import { AST_NODE_TYPES } from '@typescript-eslint/types';
 import { ASTUtils } from '@typescript-eslint/utils';
 import { isMatching, P, match } from 'ts-pattern';
 import { AST_NODE_TYPES as AST_NODE_TYPES$1, simpleTraverse } from '@typescript-eslint/typescript-estree';
+import { zip } from '@eslint-react/types';
 import { toLowerCase, delimiterCase, replace } from 'string-ts';
 
 // src/function-init-path.ts

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@eslint-react/ast",
-  "version": "1.20.2-next.1",
+  "version": "1.20.2-next.3",
   "description": "ESLint React's TSESTree AST utility module.",
   "homepage": "https://github.com/rel1cx/eslint-react",
   "bugs": {
@@ -41,8 +41,8 @@
     "birecord": "^0.1.1",
     "string-ts": "^2.2.0",
     "ts-pattern": "^5.6.0",
-    "@eslint-react/types": "1.20.2-next.1",
-    "@eslint-react/tools": "1.20.2-next.1"
+    "@eslint-react/eff": "1.20.2-next.3",
+    "@eslint-react/types": "1.20.2-next.3"
   },
   "devDependencies": {
     "tsup": "^8.3.5",