@solvro/config 2.0.0 → 2.0.2

package/dist/{nestjs-NIUFGFP5.js → nestjs-33SQ4ZD2.js}

@@ -4,7 +4,7 @@ import {
 import {
   typescriptStrict,
   unicorn
-} from "./chunk-OEFF22F3.js";
+} from "./chunk-VD4FWSAD.js";
 import {
   imports
 } from "./chunk-VSUL3MI5.js";
@@ -73,4 +73,4 @@ var nestjsPreset = async () => {
 export {
   nestjsPreset
 };
-//# sourceMappingURL=nestjs-NIUFGFP5.js.map
+//# sourceMappingURL=nestjs-33SQ4ZD2.js.map

package/dist/{node-FDTIQUMU.js → node-RC2VAG45.js}

@@ -4,7 +4,7 @@ import {
 import {
   typescriptStrict,
   unicorn
-} from "./chunk-OEFF22F3.js";
+} from "./chunk-VD4FWSAD.js";
 import {
   imports
 } from "./chunk-VSUL3MI5.js";
@@ -24,4 +24,4 @@ var nodePreset = () => [
 export {
   nodePreset
 };
-//# sourceMappingURL=node-FDTIQUMU.js.map
+//# sourceMappingURL=node-RC2VAG45.js.map

package/dist/{react-UAVCCK2N.js → react-PWJWWBLW.js}

@@ -1,7 +1,7 @@
 import {
   typescriptStrict,
   unicorn
-} from "./chunk-OEFF22F3.js";
+} from "./chunk-VD4FWSAD.js";
 import {
   imports
 } from "./chunk-VSUL3MI5.js";
@@ -444,16 +444,16 @@ function getInnermostScope(initialScope, node) {
   return scope;
 }
 function findVariable(initialScope, nameOrNode) {
-  let name8 = "";
+  let name10 = "";
   let scope = initialScope;
   if (typeof nameOrNode === "string") {
-    name8 = nameOrNode;
+    name10 = nameOrNode;
   } else {
-    name8 = nameOrNode.name;
+    name10 = nameOrNode.name;
     scope = getInnermostScope(scope, nameOrNode);
   }
   while (scope != null) {
-    const variable = scope.set.get(name8);
+    const variable = scope.set.get(name10);
     if (variable != null) {
       return variable;
     }
@@ -611,10 +611,10 @@ var callPassThrough = /* @__PURE__ */ new Set([
   Object.preventExtensions,
   Object.seal
 ]);
-function getPropertyDescriptor(object, name8) {
+function getPropertyDescriptor(object, name10) {
   let x = object;
   while ((typeof x === "object" || typeof x === "function") && x !== null) {
-    const d = Object.getOwnPropertyDescriptor(x, name8);
+    const d = Object.getOwnPropertyDescriptor(x, name10);
     if (d) {
       return d;
     }
@@ -622,8 +622,8 @@ function getPropertyDescriptor(object, name8) {
   }
   return null;
 }
-function isGetter(object, name8) {
-  const d = getPropertyDescriptor(object, name8);
+function isGetter(object, name10) {
+  const d = getPropertyDescriptor(object, name10);
   return d != null && d.get != null;
 }
 function getElementValues(nodeList, initialScope) {
@@ -1484,8 +1484,8 @@ ReferenceTracker.READ = READ;
 ReferenceTracker.CALL = CALL;
 ReferenceTracker.CONSTRUCT = CONSTRUCT;
 ReferenceTracker.ESM = ESM;
-function exceptDefault(name8, index) {
-  return !(index === 1 && name8 === "default");
+function exceptDefault(name10, index) {
+  return !(index === 1 && name10 === "default");
 }
 
 // node_modules/eslint-plugin-react-you-might-not-need-an-effect/src/util/ast.js
@@ -1506,17 +1506,13 @@ var findDownstreamNodes = (context, topNode, type) => {
   });
   return nodes;
 };
-var getUpstreamVariables = (context, node, filter, visited = /* @__PURE__ */ new Set()) => {
-  if (visited.has(node)) {
+var getUpstreamVariables = (context, variable, filter, visited = /* @__PURE__ */ new Set()) => {
+  if (visited.has(variable)) {
     return [];
   }
-  visited.add(node);
-  const variable = findVariable(context.sourceCode.getScope(node), node);
-  if (!variable) {
-    return [];
-  }
-  const upstreamVariables = variable.defs.filter((def) => !!def.node.init).filter((def) => filter(def.node)).flatMap((def) => findDownstreamNodes(context, def.node.init, "Identifier")).flatMap(
-    (identifier) => getUpstreamVariables(context, identifier, filter, visited)
+  visited.add(variable);
+  const upstreamVariables = variable.defs.filter((def) => !!def.node.init).filter((def) => filter(def.node)).flatMap((def) => getDownstreamRefs(context, def.node.init)).map((ref) => ref.resolved).filter(Boolean).flatMap(
+    (variable2) => getUpstreamVariables(context, variable2, filter, visited)
   );
   return upstreamVariables.length === 0 ? [variable] : upstreamVariables;
 };
@@ -1550,6 +1546,7 @@ var isUseState = (node) => node.type === "VariableDeclarator" && node.init && no
 (node.id.elements.length === 1 || node.id.elements.length === 2) && node.id.elements.every((el) => {
   return !el || el.type === "Identifier";
 });
+var isUseRef = (node) => node.type === "VariableDeclarator" && node.init && node.init.type === "CallExpression" && node.init.callee.name === "useRef" && node.id.type === "Identifier";
 var isUseEffect = (node) => node.type === "CallExpression" && (node.callee.type === "Identifier" && (node.callee.name === "useEffect" || node.callee.name === "useLayoutEffect") || node.callee.type === "MemberExpression" && node.callee.object.name === "React" && (node.callee.property.name === "useEffect" || node.callee.property.name === "useLayoutEffect"));
 var getEffectFn = (node) => {
   if (!isUseEffect(node) || node.arguments.length < 1) {
@@ -1579,13 +1576,14 @@ function getDependenciesRefs(context, node) {
   return getDownstreamRefs(context, depsArr);
 }
 var isFnRef = (ref) => getCallExpr(ref) !== void 0;
-var isStateSetter = (context, ref) => isFnRef(ref) && getUpstreamReactVariables(context, ref.identifier).notEmptyEvery(
+var isStateSetter = (context, ref) => isFnRef(ref) && getUpstreamReactVariables(context, ref.resolved).notEmptyEvery(
   (variable) => isState(variable)
 );
-var isPropCallback = (context, ref) => isFnRef(ref) && getUpstreamReactVariables(context, ref.identifier).notEmptyEvery(
+var isPropCallback = (context, ref) => isFnRef(ref) && getUpstreamReactVariables(context, ref.resolved).notEmptyEvery(
   (variable) => isProp(variable)
 );
 var isState = (variable) => variable.defs.some((def) => isUseState(def.node));
+var isRef = (variable) => variable.defs.some((def) => isUseRef(def.node));
 var isProp = (variable) => variable.defs.some(
   (def) => def.type === "Parameter" && (isReactFunctionalComponent(getDeclNode(def.node)) || isCustomHook(getDeclNode(def.node)))
 );
@@ -1594,7 +1592,7 @@ var isHOCProp = (variable) => variable.defs.some(
 );
 var getDeclNode = (node) => node.type === "ArrowFunctionExpression" ? node.parent.type === "CallExpression" ? node.parent.parent : node.parent : node;
 var getUseStateNode = (context, ref) => {
-  return getUpstreamReactVariables(context, ref.identifier).find((variable) => isState(variable))?.defs.find((def) => isUseState(def.node))?.node;
+  return getUpstreamReactVariables(context, ref.resolved).find((variable) => isState(variable))?.defs.find((def) => isUseState(def.node))?.node;
 };
 var isDirectCall = (node) => {
   if (!node) {
@@ -1635,6 +1633,9 @@ var countUseStates = (context, componentNode) => {
   });
   return count;
 };
+var countCalls = (ref) => ref.resolved.references.filter(
+  (ref2) => ref2.identifier.parent.type === "CallExpression"
+).length;
 var findContainingNode = (node) => {
   if (!node) {
     return void 0;
@@ -1644,18 +1645,18 @@ var findContainingNode = (node) => {
     return findContainingNode(node.parent);
   }
 };
-var getUpstreamReactVariables = (context, node) => getUpstreamVariables(
+var getUpstreamReactVariables = (context, variable) => getUpstreamVariables(
   context,
-  node,
+  variable,
   // Stop at the *usage* of `useState` - don't go up to the `useState` variable.
   // Not needed for props - they don't go "too far".
   // We could remove this and check for the `useState` variable instead,
   // but then all our tests need to import it so we can traverse up to it.
   // And would need to change `getUseStateNode()` too?
   // TODO: Could probably organize these filters better.
-  (node2) => !isUseState(node2)
+  (node) => !isUseState(node)
 ).filter(
-  (variable) => isProp(variable) || variable.defs.every((def) => def.type !== "Parameter")
+  (variable2) => isProp(variable2) || variable2.defs.every((def) => def.type !== "Parameter")
 );
 
 // node_modules/eslint-plugin-react-you-might-not-need-an-effect/src/no-empty-effect.js
@@ -1754,9 +1755,7 @@ var rule3 = {
       const depsRefs = getDependenciesRefs(context, node);
       if (!effectFnRefs || !depsRefs) return;
       findDownstreamNodes(context, node, "IfStatement").filter((ifNode) => !ifNode.alternate).filter(
-        (ifNode) => getDownstreamRefs(context, ifNode.test).flatMap(
-          (ref) => getUpstreamReactVariables(context, ref.identifier)
-        ).notEmptyEvery((variable) => isState(variable))
+        (ifNode) => getDownstreamRefs(context, ifNode.test).flatMap((ref) => getUpstreamReactVariables(context, ref.resolved)).notEmptyEvery((variable) => isState(variable))
       ).forEach((ifNode) => {
         context.report({
           node: ifNode.test,
@@ -1767,22 +1766,22 @@ var rule3 = {
   })
 };
 
-// node_modules/eslint-plugin-react-you-might-not-need-an-effect/src/no-parent-child-coupling.js
+// node_modules/eslint-plugin-react-you-might-not-need-an-effect/src/no-pass-live-state-to-parent.js
 init_esm_shims();
-var name4 = "no-parent-child-coupling";
+var name4 = "no-pass-live-state-to-parent";
 var messages4 = {
-  avoidParentChildCoupling: "avoidParentChildCoupling"
+  avoidPassingLiveStateToParent: "avoidPassingLiveStateToParent"
 };
 var rule4 = {
   meta: {
     type: "suggestion",
     docs: {
-      description: "Disallow coupling parent behavior or state to a child component in an effect.",
+      description: "Disallow passing live state to parent components in an effect.",
       url: "https://react.dev/learn/you-might-not-need-an-effect#notifying-parent-components-about-state-changes"
     },
     schema: [],
     messages: {
-      [messages4.avoidParentChildCoupling]: "Avoid coupling parent behavior or state to a child component. Instead, lift shared logic or state up to the parent."
+      [messages4.avoidPassingLiveStateToParent]: "Avoid passing live state to parents in an effect. Instead, lift the state to the parent and pass it down to the child as a prop."
     }
   },
   create: (context) => ({
@@ -1791,11 +1790,15 @@ var rule4 = {
       const effectFnRefs = getEffectFnRefs(context, node);
       const depsRefs = getDependenciesRefs(context, node);
       if (!effectFnRefs || !depsRefs) return;
-      effectFnRefs.filter(isFnRef).filter((ref) => isDirectCall(ref.identifier)).forEach((ref) => {
-        if (isPropCallback(context, ref) && !isHOCProp(ref.resolved)) {
+      effectFnRefs.filter(isFnRef).filter((ref) => isDirectCall(ref.identifier)).filter(
+        (ref) => isPropCallback(context, ref) && !isHOCProp(ref.resolved)
+      ).forEach((ref) => {
+        const callExpr = getCallExpr(ref);
+        const argsUpstreamVariables = callExpr.arguments.flatMap((arg) => getDownstreamRefs(context, arg)).flatMap((ref2) => getUpstreamReactVariables(context, ref2.resolved));
+        if (argsUpstreamVariables.some((variable) => isState(variable))) {
           context.report({
-            node: getCallExpr(ref),
-            messageId: messages4.avoidParentChildCoupling
+            node: callExpr,
+            messageId: messages4.avoidPassingLiveStateToParent
           });
         }
       });
@@ -1864,17 +1867,12 @@ var rule6 = {
       const effectFnRefs = getEffectFnRefs(context, node);
       const depsRefs = getDependenciesRefs(context, node);
       if (!effectFnRefs || !depsRefs) return;
-      const isAllDepsInternal = depsRefs.flatMap((ref) => getUpstreamReactVariables(context, ref.identifier)).notEmptyEvery(
+      const isAllDepsInternal = depsRefs.flatMap((ref) => getUpstreamReactVariables(context, ref.resolved)).notEmptyEvery(
         (variable) => isState(variable) || isProp(variable) && !isHOCProp(variable)
       );
       effectFnRefs.filter(isFnRef).filter((ref) => isDirectCall(ref.identifier)).filter((ref) => isStateSetter(context, ref)).forEach((ref) => {
         const callExpr = getCallExpr(ref);
-        const argsRefs = callExpr.arguments.flatMap(
-          (arg) => getDownstreamRefs(context, arg)
-        );
-        const argsUpstreamVariables = argsRefs.flatMap(
-          (ref2) => getUpstreamReactVariables(context, ref2.identifier)
-        );
+        const argsUpstreamVariables = callExpr.arguments.flatMap((arg) => getDownstreamRefs(context, arg)).flatMap((ref2) => getUpstreamReactVariables(context, ref2.resolved));
         const isAllArgsInternal = argsUpstreamVariables.notEmptyEvery(
           (variable) => isState(variable) || isProp(variable) && !isHOCProp(variable)
         );
@@ -1894,20 +1892,6 @@ var rule6 = {
 
 // node_modules/eslint-plugin-react-you-might-not-need-an-effect/src/no-derived-state.js
 init_esm_shims();
-
-// node_modules/eslint-plugin-react-you-might-not-need-an-effect/src/util/javascript.js
-init_esm_shims();
-Array.prototype.notEmptyEvery = function(predicate) {
-  return this.length > 0 && this.every(predicate);
-};
-var arraysEqual = (arr1, arr2) => {
-  if (arr1.length !== arr2.length) {
-    return false;
-  }
-  return arr1.every((element, index) => element === arr2[index]);
-};
-
-// node_modules/eslint-plugin-react-you-might-not-need-an-effect/src/no-derived-state.js
 var name7 = "no-derived-state";
 var messages7 = {
   avoidDerivedState: "avoidDerivedState"
@@ -1934,27 +1918,19 @@ var rule7 = {
         const callExpr = getCallExpr(ref);
         const useStateNode = getUseStateNode(context, ref);
         const stateName = (useStateNode.id.elements[0] ?? useStateNode.id.elements[1])?.name;
-        const argsRefs = callExpr.arguments.flatMap(
-          (arg) => getDownstreamRefs(context, arg)
-        );
-        const argsUpstreamVariables = argsRefs.flatMap(
-          (ref2) => getUpstreamReactVariables(context, ref2.identifier)
+        const argsUpstreamVars = callExpr.arguments.flatMap((arg) => getDownstreamRefs(context, arg)).flatMap((ref2) => getUpstreamReactVariables(context, ref2.resolved));
+        const depsUpstreamVars = depsRefs.flatMap(
+          (ref2) => getUpstreamReactVariables(context, ref2.resolved)
         );
-        const isAllArgsInternal = argsUpstreamVariables.notEmptyEvery(
+        const isAllArgsInternal = argsUpstreamVars.notEmptyEvery(
           (variable) => isState(variable) || isProp(variable) && !isHOCProp(variable)
         );
-        const isAllArgsInDeps = argsRefs.filter(
-          (ref2) => ref2.resolved.defs.every((def) => def.type !== "Parameter")
-        ).notEmptyEvery(
-          (argRef) => depsRefs.some(
-            (depRef) => arraysEqual(
-              getUpstreamReactVariables(context, argRef.identifier),
-              getUpstreamReactVariables(context, depRef.identifier)
-            )
-          )
+        const isAllArgsInDeps = argsUpstreamVars.notEmptyEvery(
+          (argVar) => depsUpstreamVars.some((depVar) => argVar.name === depVar.name)
         );
-        const isStateSetterCalledOnce = ref.resolved.references.length - 1 === 1;
-        if (isAllArgsInternal || isAllArgsInDeps && isStateSetterCalledOnce) {
+        if (isAllArgsInternal || // In this case the derived state will always be in sync,
+        // thus it could be computed directly during render
+        isAllArgsInDeps && countCalls(ref) === 1) {
           context.report({
             node: callExpr,
             messageId: messages7.avoidDerivedState,
@@ -1966,8 +1942,92 @@ var rule7 = {
   })
 };
 
+// node_modules/eslint-plugin-react-you-might-not-need-an-effect/src/no-pass-data-to-parent.js
+init_esm_shims();
+var name8 = "no-pass-data-to-parent";
+var messages8 = {
+  avoidPassingDataToParent: "avoidPassingDataToParent"
+};
+var rule8 = {
+  meta: {
+    type: "suggestion",
+    docs: {
+      description: "Disallow passing data to parents in an effect.",
+      url: "https://react.dev/learn/you-might-not-need-an-effect#passing-data-to-the-parent"
+    },
+    schema: [],
+    messages: {
+      [messages8.avoidPassingDataToParent]: "Avoid passing data to parents in an effect. Instead, let the parent fetch the data itself and pass it down to the child as a prop."
+    }
+  },
+  create: (context) => ({
+    CallExpression: (node) => {
+      if (!isUseEffect(node)) return;
+      const effectFnRefs = getEffectFnRefs(context, node);
+      const depsRefs = getDependenciesRefs(context, node);
+      if (!effectFnRefs || !depsRefs) return;
+      effectFnRefs.filter(isFnRef).filter((ref) => isDirectCall(ref.identifier)).filter(
+        (ref) => isPropCallback(context, ref) && !isHOCProp(ref.resolved)
+      ).forEach((ref) => {
+        const callExpr = getCallExpr(ref);
+        const argsUpstreamVariables = callExpr.arguments.flatMap((arg) => getDownstreamRefs(context, arg)).flatMap((ref2) => getUpstreamReactVariables(context, ref2.resolved));
+        if (callExpr.arguments.some((arg) => arg.type === "Literal") || argsUpstreamVariables.some(
+          (variable) => !isState(variable) && !isRef(variable)
+        )) {
+          context.report({
+            node: callExpr,
+            messageId: messages8.avoidPassingDataToParent
+          });
+        }
+      });
+    }
+  })
+};
+
+// node_modules/eslint-plugin-react-you-might-not-need-an-effect/src/no-manage-parent.js
+init_esm_shims();
+var name9 = "no-manage-parent";
+var messages9 = {
+  avoidManagingParent: "avoidManagingParent"
+};
+var rule9 = {
+  meta: {
+    type: "problem",
+    docs: {
+      description: "Disallow effects that only use props."
+    },
+    schema: [],
+    messages: {
+      [messages9.avoidManagingParent]: "This effect only uses props. Consider lifting the logic up to the parent."
+    }
+  },
+  create: (context) => ({
+    CallExpression: (node) => {
+      if (!isUseEffect(node)) return;
+      const effectFnRefs = getEffectFnRefs(context, node);
+      const depsRefs = getDependenciesRefs(context, node);
+      if (!effectFnRefs || !depsRefs) return;
+      if (effectFnRefs.length === 0) return;
+      if (effectFnRefs.concat(depsRefs).every((ref) => isProp(ref.resolved) && !isHOCProp(ref.resolved))) {
+        context.report({
+          node,
+          messageId: messages9.avoidManagingParent
+        });
+      }
+    }
+  })
+};
+
 // node_modules/eslint-plugin-react-you-might-not-need-an-effect/src/index.js
 import globals2 from "globals";
+
+// node_modules/eslint-plugin-react-you-might-not-need-an-effect/src/util/javascript.js
+init_esm_shims();
+Array.prototype.notEmptyEvery = function(predicate) {
+  return this.length > 0 && this.every(predicate);
+};
+
+// node_modules/eslint-plugin-react-you-might-not-need-an-effect/src/index.js
 var plugin = {
   meta: {
     name: "react-you-might-not-need-an-effect"
@@ -1978,6 +2038,8 @@ var plugin = {
     [name2]: rule2,
     [name3]: rule3,
     [name4]: rule4,
+    [name8]: rule8,
+    [name9]: rule9,
     [name5]: rule5,
     [name6]: rule6,
     [name7]: rule7
@@ -2018,12 +2080,14 @@ Object.assign(plugin.configs, {
 var src_default = plugin;
 
 // src/eslint/configs/react.ts
-import { isPackageExists } from "local-pkg";
+import { isPackageListedSync } from "local-pkg";
 var nextJsPackages = ["next"];
 var vitePackages = ["vite"];
 async function react() {
-  const isUsingNext = nextJsPackages.some((index) => isPackageExists(index));
-  const isUsingVite = vitePackages.some((index) => isPackageExists(index));
+  const isUsingNext = nextJsPackages.some(
+    (index) => isPackageListedSync(index)
+  );
+  const isUsingVite = vitePackages.some((index) => isPackageListedSync(index));
   const nextjsConfig = [];
   if (isUsingNext) {
     const nextPlugin = await import("@next/eslint-plugin-next").then(
@@ -2138,4 +2202,4 @@ export {
 eslint-utils/index.mjs:
   (*! @author Toru Nagashima <https://github.com/mysticatea> *)
 */
-//# sourceMappingURL=react-UAVCCK2N.js.map
+//# sourceMappingURL=react-PWJWWBLW.js.map