@oncoursesystems/eslint-config 1.0.0

package/dist/index.js

@@ -0,0 +1,1095 @@
+import {
+  require_dist
+} from "./chunk-3DH23OWQ.js";
+import {
+  __toESM,
+  init_esm_shims
+} from "./chunk-UVR5GK7I.js";
+
+// src/index.ts
+init_esm_shims();
+import { antfu } from "@antfu/eslint-config";
+
+// src/config.ts
+init_esm_shims();
+
+// src/configs/expo.ts
+init_esm_shims();
+import { ensurePackages, interopDefault } from "@antfu/eslint-config";
+async function expo() {
+  await ensurePackages(["eslint-plugin-expo"]);
+  const pluginExpo = await interopDefault(import("./build-MNP2VQ2J.js"));
+  return [
+    {
+      name: "oncourse/expo/setup",
+      plugins: {
+        expo: pluginExpo
+      }
+    },
+    {
+      name: "oncourse/expo/rules",
+      rules: {
+        "expo/no-dynamic-env-var": ["error"],
+        "expo/no-env-var-destructuring": ["error"]
+      }
+    }
+  ];
+}
+
+// src/configs/javascript.ts
+init_esm_shims();
+var sortOptions = Object.freeze({
+  ignoreCase: false,
+  partitionByNewLine: true,
+  type: "natural"
+});
+function javascript() {
+  return {
+    files: ["**/*.{cjs,js,mjs,ts}"],
+    rules: {
+      "perfectionist/sort-array-includes": ["error", sortOptions],
+      "perfectionist/sort-enums": ["error", sortOptions],
+      "perfectionist/sort-imports": [
+        "error",
+        {
+          environment: "node",
+          groups: [["builtin", "external"], "internal", "parent", "sibling"],
+          ignoreCase: false,
+          internalPattern: ["@/**", "~/**"],
+          type: "natural"
+        }
+      ],
+      "perfectionist/sort-interfaces": ["error", sortOptions],
+      "perfectionist/sort-intersection-types": ["error", sortOptions],
+      "perfectionist/sort-object-types": ["error", sortOptions],
+      "perfectionist/sort-objects": ["error", sortOptions],
+      "perfectionist/sort-sets": ["error", sortOptions],
+      "perfectionist/sort-union-types": ["error", sortOptions],
+      "perfectionist/sort-variable-declarations": ["error", sortOptions]
+    }
+  };
+}
+
+// src/configs/sencha.ts
+init_esm_shims();
+import { ensurePackages as ensurePackages2, interopDefault as interopDefault2 } from "@antfu/eslint-config";
+async function sencha() {
+  await ensurePackages2(["@sencha/eslint-plugin-extjs"]);
+  const pluginSencha = await interopDefault2(import("./lib-DX5OAELA.js"));
+  return [
+    {
+      name: "oncourse/sencha/setup",
+      plugins: {
+        "@sencha/extjs": pluginSencha
+      }
+    },
+    {
+      name: "oncourse/sencha/rules",
+      rules: {
+        ...pluginSencha.configs.recommended.rules
+      }
+    }
+  ];
+}
+
+// src/config.ts
+function oncourseConfigs(options) {
+  return [
+    options?.expo ? expo() : {},
+    javascript(),
+    options?.sencha ? sencha() : {},
+    {
+      files: ["**/.vscode/*.json"],
+      rules: {
+        "jsonc/sort-array-values": [
+          "error",
+          { order: { natural: true, type: "asc" }, pathPattern: "^.*$" }
+        ],
+        "jsonc/sort-keys": [
+          "error",
+          "asc",
+          { caseSensitive: true, natural: true }
+        ]
+      }
+    }
+  ];
+}
+
+// src/options.ts
+init_esm_shims();
+
+// src/configs/react.ts
+init_esm_shims();
+
+// node_modules/.pnpm/@tanstack+eslint-plugin-query@5.61.3_eslint@9.15.0_jiti@2.4.0__typescript@5.7.2/node_modules/@tanstack/eslint-plugin-query/dist/esm/index.js
+init_esm_shims();
+
+// node_modules/.pnpm/@tanstack+eslint-plugin-query@5.61.3_eslint@9.15.0_jiti@2.4.0__typescript@5.7.2/node_modules/@tanstack/eslint-plugin-query/dist/esm/rules.js
+init_esm_shims();
+
+// node_modules/.pnpm/@tanstack+eslint-plugin-query@5.61.3_eslint@9.15.0_jiti@2.4.0__typescript@5.7.2/node_modules/@tanstack/eslint-plugin-query/dist/esm/rules/exhaustive-deps/exhaustive-deps.rule.js
+init_esm_shims();
+var import_utils4 = __toESM(require_dist(), 1);
+
+// node_modules/.pnpm/@tanstack+eslint-plugin-query@5.61.3_eslint@9.15.0_jiti@2.4.0__typescript@5.7.2/node_modules/@tanstack/eslint-plugin-query/dist/esm/utils/ast-utils.js
+init_esm_shims();
+var import_utils = __toESM(require_dist(), 1);
+
+// node_modules/.pnpm/@tanstack+eslint-plugin-query@5.61.3_eslint@9.15.0_jiti@2.4.0__typescript@5.7.2/node_modules/@tanstack/eslint-plugin-query/dist/esm/utils/unique-by.js
+init_esm_shims();
+function uniqueBy(arr, fn) {
+  return arr.filter((x, i, a) => a.findIndex((y) => fn(x) === fn(y)) === i);
+}
+
+// node_modules/.pnpm/@tanstack+eslint-plugin-query@5.61.3_eslint@9.15.0_jiti@2.4.0__typescript@5.7.2/node_modules/@tanstack/eslint-plugin-query/dist/esm/utils/ast-utils.js
+var ASTUtils = {
+  isNodeOfOneOf(node, types) {
+    return types.includes(node.type);
+  },
+  isIdentifier(node) {
+    return node.type === import_utils.AST_NODE_TYPES.Identifier;
+  },
+  isIdentifierWithName(node, name6) {
+    return ASTUtils.isIdentifier(node) && node.name === name6;
+  },
+  isIdentifierWithOneOfNames(node, name6) {
+    return ASTUtils.isIdentifier(node) && name6.includes(node.name);
+  },
+  isProperty(node) {
+    return node.type === import_utils.AST_NODE_TYPES.Property;
+  },
+  isObjectExpression(node) {
+    return node.type === import_utils.AST_NODE_TYPES.ObjectExpression;
+  },
+  isPropertyWithIdentifierKey(node, key) {
+    return ASTUtils.isProperty(node) && ASTUtils.isIdentifierWithName(node.key, key);
+  },
+  findPropertyWithIdentifierKey(properties, key) {
+    return properties.find(
+      (x) => ASTUtils.isPropertyWithIdentifierKey(x, key)
+    );
+  },
+  getNestedIdentifiers(node) {
+    const identifiers = [];
+    if (ASTUtils.isIdentifier(node)) {
+      identifiers.push(node);
+    }
+    if ("arguments" in node) {
+      node.arguments.forEach((x) => {
+        identifiers.push(...ASTUtils.getNestedIdentifiers(x));
+      });
+    }
+    if ("elements" in node) {
+      node.elements.forEach((x) => {
+        if (x !== null) {
+          identifiers.push(...ASTUtils.getNestedIdentifiers(x));
+        }
+      });
+    }
+    if ("properties" in node) {
+      node.properties.forEach((x) => {
+        identifiers.push(...ASTUtils.getNestedIdentifiers(x));
+      });
+    }
+    if ("expressions" in node) {
+      node.expressions.forEach((x) => {
+        identifiers.push(...ASTUtils.getNestedIdentifiers(x));
+      });
+    }
+    if ("left" in node) {
+      identifiers.push(...ASTUtils.getNestedIdentifiers(node.left));
+    }
+    if ("right" in node) {
+      identifiers.push(...ASTUtils.getNestedIdentifiers(node.right));
+    }
+    if (node.type === import_utils.AST_NODE_TYPES.Property) {
+      identifiers.push(...ASTUtils.getNestedIdentifiers(node.value));
+    }
+    if (node.type === import_utils.AST_NODE_TYPES.SpreadElement) {
+      identifiers.push(...ASTUtils.getNestedIdentifiers(node.argument));
+    }
+    if (node.type === import_utils.AST_NODE_TYPES.MemberExpression) {
+      identifiers.push(...ASTUtils.getNestedIdentifiers(node.object));
+    }
+    if (node.type === import_utils.AST_NODE_TYPES.UnaryExpression) {
+      identifiers.push(...ASTUtils.getNestedIdentifiers(node.argument));
+    }
+    if (node.type === import_utils.AST_NODE_TYPES.ChainExpression) {
+      identifiers.push(...ASTUtils.getNestedIdentifiers(node.expression));
+    }
+    if (node.type === import_utils.AST_NODE_TYPES.TSNonNullExpression) {
+      identifiers.push(...ASTUtils.getNestedIdentifiers(node.expression));
+    }
+    if (node.type === import_utils.AST_NODE_TYPES.ArrowFunctionExpression) {
+      identifiers.push(...ASTUtils.getNestedIdentifiers(node.body));
+    }
+    if (node.type === import_utils.AST_NODE_TYPES.FunctionExpression) {
+      identifiers.push(...ASTUtils.getNestedIdentifiers(node.body));
+    }
+    if (node.type === import_utils.AST_NODE_TYPES.BlockStatement) {
+      identifiers.push(
+        ...node.body.map((body) => ASTUtils.getNestedIdentifiers(body)).flat()
+      );
+    }
+    if (node.type === import_utils.AST_NODE_TYPES.ReturnStatement && node.argument) {
+      identifiers.push(...ASTUtils.getNestedIdentifiers(node.argument));
+    }
+    return identifiers;
+  },
+  isAncestorIsCallee(identifier) {
+    let previousNode = identifier;
+    let currentNode = identifier.parent;
+    while (currentNode !== void 0) {
+      if (currentNode.type === import_utils.AST_NODE_TYPES.CallExpression && currentNode.callee === previousNode) {
+        return true;
+      }
+      if (currentNode.type !== import_utils.AST_NODE_TYPES.MemberExpression) {
+        return false;
+      }
+      previousNode = currentNode;
+      currentNode = currentNode.parent;
+    }
+    return false;
+  },
+  traverseUpOnly(identifier, allowedNodeTypes) {
+    const parent = identifier.parent;
+    if (parent !== void 0 && allowedNodeTypes.includes(parent.type)) {
+      return ASTUtils.traverseUpOnly(parent, allowedNodeTypes);
+    }
+    return identifier;
+  },
+  isDeclaredInNode(params) {
+    const { functionNode, reference, scopeManager } = params;
+    const scope = scopeManager.acquire(functionNode);
+    if (scope === null) {
+      return false;
+    }
+    return scope.set.has(reference.identifier.name);
+  },
+  getExternalRefs(params) {
+    const { scopeManager, sourceCode, node } = params;
+    const scope = scopeManager.acquire(node);
+    if (scope === null) {
+      return [];
+    }
+    const references = scope.references.filter((x) => x.isRead() && !scope.set.has(x.identifier.name)).map((x) => {
+      const referenceNode = ASTUtils.traverseUpOnly(x.identifier, [
+        import_utils.AST_NODE_TYPES.MemberExpression,
+        import_utils.AST_NODE_TYPES.Identifier
+      ]);
+      return {
+        variable: x,
+        node: referenceNode,
+        text: sourceCode.getText(referenceNode)
+      };
+    });
+    const localRefIds = new Set(
+      [...scope.set.values()].map((x) => sourceCode.getText(x.identifiers[0]))
+    );
+    const externalRefs = references.filter(
+      (x) => x.variable.resolved === null || !localRefIds.has(x.text)
+    );
+    return uniqueBy(externalRefs, (x) => x.text).map((x) => x.variable);
+  },
+  mapKeyNodeToText(node, sourceCode) {
+    return sourceCode.getText(
+      ASTUtils.traverseUpOnly(node, [
+        import_utils.AST_NODE_TYPES.MemberExpression,
+        import_utils.AST_NODE_TYPES.Identifier
+      ])
+    );
+  },
+  isValidReactComponentOrHookName(identifier) {
+    return identifier !== null && identifier !== void 0 && /^(use|[A-Z])/.test(identifier.name);
+  },
+  getFunctionAncestor(sourceCode, node) {
+    var _a;
+    for (const ancestor of sourceCode.getAncestors(node)) {
+      if (ASTUtils.isNodeOfOneOf(ancestor, [
+        import_utils.AST_NODE_TYPES.FunctionDeclaration,
+        import_utils.AST_NODE_TYPES.FunctionExpression,
+        import_utils.AST_NODE_TYPES.ArrowFunctionExpression
+      ])) {
+        return ancestor;
+      }
+      if (((_a = ancestor.parent) == null ? void 0 : _a.type) === import_utils.AST_NODE_TYPES.VariableDeclarator && ancestor.parent.id.type === import_utils.AST_NODE_TYPES.Identifier && ASTUtils.isNodeOfOneOf(ancestor, [
+        import_utils.AST_NODE_TYPES.FunctionDeclaration,
+        import_utils.AST_NODE_TYPES.FunctionExpression,
+        import_utils.AST_NODE_TYPES.ArrowFunctionExpression
+      ])) {
+        return ancestor;
+      }
+    }
+    return void 0;
+  },
+  getReferencedExpressionByIdentifier(params) {
+    var _a, _b, _c;
+    const { node, context } = params;
+    const sourceCode = context.sourceCode ?? context.getSourceCode();
+    const scope = context.sourceCode.getScope(node) ? sourceCode.getScope(node) : context.getScope();
+    const resolvedNode = (_c = (_b = (_a = scope.references.find((ref) => ref.identifier === node)) == null ? void 0 : _a.resolved) == null ? void 0 : _b.defs[0]) == null ? void 0 : _c.node;
+    if ((resolvedNode == null ? void 0 : resolvedNode.type) !== import_utils.AST_NODE_TYPES.VariableDeclarator) {
+      return null;
+    }
+    return resolvedNode.init;
+  },
+  getClosestVariableDeclarator(node) {
+    let currentNode = node;
+    while (currentNode.type !== import_utils.AST_NODE_TYPES.Program) {
+      if (currentNode.type === import_utils.AST_NODE_TYPES.VariableDeclarator) {
+        return currentNode;
+      }
+      currentNode = currentNode.parent;
+    }
+    return void 0;
+  },
+  getNestedReturnStatements(node) {
+    const returnStatements = [];
+    if (node.type === import_utils.AST_NODE_TYPES.ReturnStatement) {
+      returnStatements.push(node);
+    }
+    if ("body" in node && node.body !== void 0 && node.body !== null) {
+      Array.isArray(node.body) ? node.body.forEach((x) => {
+        returnStatements.push(...ASTUtils.getNestedReturnStatements(x));
+      }) : returnStatements.push(
+        ...ASTUtils.getNestedReturnStatements(node.body)
+      );
+    }
+    if ("consequent" in node) {
+      Array.isArray(node.consequent) ? node.consequent.forEach((x) => {
+        returnStatements.push(...ASTUtils.getNestedReturnStatements(x));
+      }) : returnStatements.push(
+        ...ASTUtils.getNestedReturnStatements(node.consequent)
+      );
+    }
+    if ("alternate" in node && node.alternate !== null) {
+      Array.isArray(node.alternate) ? node.alternate.forEach((x) => {
+        returnStatements.push(...ASTUtils.getNestedReturnStatements(x));
+      }) : returnStatements.push(
+        ...ASTUtils.getNestedReturnStatements(node.alternate)
+      );
+    }
+    if ("cases" in node) {
+      node.cases.forEach((x) => {
+        returnStatements.push(...ASTUtils.getNestedReturnStatements(x));
+      });
+    }
+    if ("block" in node) {
+      returnStatements.push(...ASTUtils.getNestedReturnStatements(node.block));
+    }
+    if ("handler" in node && node.handler !== null) {
+      returnStatements.push(...ASTUtils.getNestedReturnStatements(node.handler));
+    }
+    if ("finalizer" in node && node.finalizer !== null) {
+      returnStatements.push(
+        ...ASTUtils.getNestedReturnStatements(node.finalizer)
+      );
+    }
+    if ("expression" in node && node.expression !== true && node.expression !== false) {
+      returnStatements.push(
+        ...ASTUtils.getNestedReturnStatements(node.expression)
+      );
+    }
+    if ("test" in node && node.test !== null) {
+      returnStatements.push(...ASTUtils.getNestedReturnStatements(node.test));
+    }
+    return returnStatements;
+  }
+};
+
+// node_modules/.pnpm/@tanstack+eslint-plugin-query@5.61.3_eslint@9.15.0_jiti@2.4.0__typescript@5.7.2/node_modules/@tanstack/eslint-plugin-query/dist/esm/utils/get-docs-url.js
+init_esm_shims();
+var getDocsUrl = (ruleName) => `https://tanstack.com/query/latest/docs/eslint/${ruleName}`;
+
+// node_modules/.pnpm/@tanstack+eslint-plugin-query@5.61.3_eslint@9.15.0_jiti@2.4.0__typescript@5.7.2/node_modules/@tanstack/eslint-plugin-query/dist/esm/utils/detect-react-query-imports.js
+init_esm_shims();
+var import_utils2 = __toESM(require_dist(), 1);
+function detectTanstackQueryImports(create) {
+  return (context, optionsWithDefault) => {
+    const tanstackQueryImportSpecifiers = [];
+    const helpers = {
+      isSpecificTanstackQueryImport(node, source) {
+        return !!tanstackQueryImportSpecifiers.find((specifier) => {
+          if (specifier.type === import_utils2.TSESTree.AST_NODE_TYPES.ImportSpecifier && specifier.parent.type === import_utils2.TSESTree.AST_NODE_TYPES.ImportDeclaration && specifier.parent.source.value === source) {
+            return node.name === specifier.local.name;
+          }
+          return false;
+        });
+      },
+      isTanstackQueryImport(node) {
+        return !!tanstackQueryImportSpecifiers.find((specifier) => {
+          if (specifier.type === import_utils2.TSESTree.AST_NODE_TYPES.ImportSpecifier) {
+            return node.name === specifier.local.name;
+          }
+          return false;
+        });
+      }
+    };
+    const detectionInstructions = {
+      ImportDeclaration(node) {
+        if (node.specifiers.length > 0 && node.importKind === "value" && node.source.value.startsWith("@tanstack/") && node.source.value.endsWith("-query")) {
+          tanstackQueryImportSpecifiers.push(...node.specifiers);
+        }
+      }
+    };
+    const ruleInstructions = create(context, optionsWithDefault, helpers);
+    const enhancedRuleInstructions = {};
+    const allKeys = new Set(
+      Object.keys(detectionInstructions).concat(Object.keys(ruleInstructions))
+    );
+    allKeys.forEach((instruction) => {
+      enhancedRuleInstructions[instruction] = (node) => {
+        var _a, _b;
+        if (instruction in detectionInstructions) {
+          (_a = detectionInstructions[instruction]) == null ? void 0 : _a.call(detectionInstructions, node);
+        }
+        if (ruleInstructions[instruction]) {
+          return (_b = ruleInstructions[instruction]) == null ? void 0 : _b.call(ruleInstructions, node);
+        }
+        return void 0;
+      };
+    });
+    return enhancedRuleInstructions;
+  };
+}
+
+// node_modules/.pnpm/@tanstack+eslint-plugin-query@5.61.3_eslint@9.15.0_jiti@2.4.0__typescript@5.7.2/node_modules/@tanstack/eslint-plugin-query/dist/esm/rules/exhaustive-deps/exhaustive-deps.utils.js
+init_esm_shims();
+var import_utils3 = __toESM(require_dist(), 1);
+var ExhaustiveDepsUtils = {
+  isRelevantReference(params) {
+    const { sourceCode, reference, scopeManager, node } = params;
+    const component = ASTUtils.getFunctionAncestor(sourceCode, node);
+    if (component === void 0) {
+      return false;
+    }
+    if (!ASTUtils.isDeclaredInNode({
+      scopeManager,
+      reference,
+      functionNode: component
+    })) {
+      return false;
+    }
+    return reference.identifier.name !== "undefined" && reference.identifier.parent.type !== import_utils3.AST_NODE_TYPES.NewExpression && !ExhaustiveDepsUtils.isInstanceOfKind(reference.identifier.parent) && !ExhaustiveDepsUtils.isQueryClientReference(reference);
+  },
+  isInstanceOfKind(node) {
+    return node.type === import_utils3.AST_NODE_TYPES.BinaryExpression && node.operator === "instanceof";
+  },
+  isQueryClientReference(reference) {
+    var _a, _b, _c;
+    const declarator = (_b = (_a = reference.resolved) == null ? void 0 : _a.defs[0]) == null ? void 0 : _b.node;
+    return (declarator == null ? void 0 : declarator.type) === import_utils3.AST_NODE_TYPES.VariableDeclarator && ((_c = declarator.init) == null ? void 0 : _c.type) === import_utils3.AST_NODE_TYPES.CallExpression && declarator.init.callee.type === import_utils3.AST_NODE_TYPES.Identifier && declarator.init.callee.name === "useQueryClient";
+  }
+};
+
+// node_modules/.pnpm/@tanstack+eslint-plugin-query@5.61.3_eslint@9.15.0_jiti@2.4.0__typescript@5.7.2/node_modules/@tanstack/eslint-plugin-query/dist/esm/rules/exhaustive-deps/exhaustive-deps.rule.js
+var QUERY_KEY = "queryKey";
+var QUERY_FN = "queryFn";
+var name = "exhaustive-deps";
+var createRule = import_utils4.ESLintUtils.RuleCreator(getDocsUrl);
+var rule = createRule({
+  name,
+  meta: {
+    type: "problem",
+    docs: {
+      description: "Exhaustive deps rule for useQuery",
+      recommended: "error"
+    },
+    messages: {
+      missingDeps: `The following dependencies are missing in your queryKey: {{deps}}`,
+      fixTo: "Fix to {{result}}"
+    },
+    hasSuggestions: true,
+    fixable: "code",
+    schema: []
+  },
+  defaultOptions: [],
+  create: detectTanstackQueryImports((context) => {
+    return {
+      Property: (node) => {
+        if (!ASTUtils.isObjectExpression(node.parent) || !ASTUtils.isIdentifierWithName(node.key, QUERY_KEY)) {
+          return;
+        }
+        const scopeManager = context.sourceCode.scopeManager;
+        const queryKey = ASTUtils.findPropertyWithIdentifierKey(
+          node.parent.properties,
+          QUERY_KEY
+        );
+        const queryFn = ASTUtils.findPropertyWithIdentifierKey(
+          node.parent.properties,
+          QUERY_FN
+        );
+        if (scopeManager === null || queryKey === void 0 || queryFn === void 0 || !ASTUtils.isNodeOfOneOf(queryFn.value, [
+          import_utils4.AST_NODE_TYPES.ArrowFunctionExpression,
+          import_utils4.AST_NODE_TYPES.FunctionExpression,
+          import_utils4.AST_NODE_TYPES.ConditionalExpression
+        ])) {
+          return;
+        }
+        let queryKeyNode = queryKey.value;
+        if (queryKeyNode.type === import_utils4.AST_NODE_TYPES.TSAsExpression && queryKeyNode.expression.type === import_utils4.AST_NODE_TYPES.ArrayExpression) {
+          queryKeyNode = queryKeyNode.expression;
+        }
+        if (queryKeyNode.type === import_utils4.AST_NODE_TYPES.Identifier) {
+          const expression = ASTUtils.getReferencedExpressionByIdentifier({
+            context,
+            node: queryKeyNode
+          });
+          if ((expression == null ? void 0 : expression.type) === import_utils4.AST_NODE_TYPES.ArrayExpression) {
+            queryKeyNode = expression;
+          }
+        }
+        const externalRefs = ASTUtils.getExternalRefs({
+          scopeManager,
+          sourceCode: context.sourceCode,
+          node: getQueryFnRelevantNode(queryFn)
+        });
+        const relevantRefs = externalRefs.filter(
+          (reference) => ExhaustiveDepsUtils.isRelevantReference({
+            sourceCode: context.sourceCode,
+            reference,
+            scopeManager,
+            node: getQueryFnRelevantNode(queryFn)
+          })
+        );
+        const existingKeys = ASTUtils.getNestedIdentifiers(queryKeyNode).map(
+          (identifier) => ASTUtils.mapKeyNodeToText(identifier, context.sourceCode)
+        );
+        const missingRefs = relevantRefs.map((ref) => ({
+          ref,
+          text: ASTUtils.mapKeyNodeToText(ref.identifier, context.sourceCode)
+        })).filter(({ ref, text }) => {
+          return !ref.isTypeReference && !ASTUtils.isAncestorIsCallee(ref.identifier) && !existingKeys.some((existingKey) => existingKey === text) && !existingKeys.includes(text.split(/[?.]/)[0] ?? "");
+        }).map(({ ref, text }) => ({
+          identifier: ref.identifier,
+          text
+        }));
+        const uniqueMissingRefs = uniqueBy(missingRefs, (x) => x.text);
+        if (uniqueMissingRefs.length > 0) {
+          const missingAsText = uniqueMissingRefs.map(
+            (ref) => ASTUtils.mapKeyNodeToText(ref.identifier, context.sourceCode)
+          ).join(", ");
+          const queryKeyValue = context.sourceCode.getText(queryKeyNode);
+          const existingWithMissing = queryKeyValue === "[]" ? `[${missingAsText}]` : queryKeyValue.replace(/\]$/, `, ${missingAsText}]`);
+          const suggestions = [];
+          if (queryKeyNode.type === import_utils4.AST_NODE_TYPES.ArrayExpression) {
+            suggestions.push({
+              messageId: "fixTo",
+              data: { result: existingWithMissing },
+              fix(fixer) {
+                return fixer.replaceText(queryKeyNode, existingWithMissing);
+              }
+            });
+          }
+          context.report({
+            node,
+            messageId: "missingDeps",
+            data: {
+              deps: uniqueMissingRefs.map((ref) => ref.text).join(", ")
+            },
+            suggest: suggestions
+          });
+        }
+      }
+    };
+  })
+});
+function getQueryFnRelevantNode(queryFn) {
+  if (queryFn.value.type !== import_utils4.AST_NODE_TYPES.ConditionalExpression) {
+    return queryFn.value;
+  }
+  if (queryFn.value.consequent.type === import_utils4.AST_NODE_TYPES.Identifier && queryFn.value.consequent.name === "skipToken") {
+    return queryFn.value.alternate;
+  }
+  return queryFn.value.consequent;
+}
+
+// node_modules/.pnpm/@tanstack+eslint-plugin-query@5.61.3_eslint@9.15.0_jiti@2.4.0__typescript@5.7.2/node_modules/@tanstack/eslint-plugin-query/dist/esm/rules/stable-query-client/stable-query-client.rule.js
+init_esm_shims();
+var import_utils5 = __toESM(require_dist(), 1);
+var name2 = "stable-query-client";
+var createRule2 = import_utils5.ESLintUtils.RuleCreator(getDocsUrl);
+var rule2 = createRule2({
+  name: name2,
+  meta: {
+    type: "problem",
+    docs: {
+      description: "Makes sure that QueryClient is stable",
+      recommended: "error"
+    },
+    messages: {
+      unstable: [
+        "QueryClient is not stable. It should be either extracted from the component or wrapped in React.useState.",
+        "See https://tkdodo.eu/blog/react-query-fa-qs#2-the-queryclient-is-not-stable"
+      ].join("\n"),
+      fixTo: "Fix to {{result}}"
+    },
+    hasSuggestions: true,
+    fixable: "code",
+    schema: []
+  },
+  defaultOptions: [],
+  create: detectTanstackQueryImports((context, _, helpers) => {
+    return {
+      NewExpression: (node) => {
+        if (node.callee.type !== import_utils5.AST_NODE_TYPES.Identifier || node.callee.name !== "QueryClient" || node.parent.type !== import_utils5.AST_NODE_TYPES.VariableDeclarator || !helpers.isSpecificTanstackQueryImport(
+          node.callee,
+          "@tanstack/react-query"
+        )) {
+          return;
+        }
+        const fnAncestor = ASTUtils.getFunctionAncestor(
+          context.sourceCode,
+          node
+        );
+        const isReactServerComponent = (fnAncestor == null ? void 0 : fnAncestor.async) === true;
+        if (!ASTUtils.isValidReactComponentOrHookName(fnAncestor == null ? void 0 : fnAncestor.id) || isReactServerComponent) {
+          return;
+        }
+        context.report({
+          node: node.parent,
+          messageId: "unstable",
+          fix: (() => {
+            const { parent } = node;
+            if (parent.id.type !== import_utils5.AST_NODE_TYPES.Identifier) {
+              return;
+            }
+            const sourceCode = context.sourceCode ?? context.getSourceCode();
+            const nodeText = sourceCode.getText(node);
+            const variableName = parent.id.name;
+            return (fixer) => {
+              return fixer.replaceTextRange(
+                [parent.range[0], parent.range[1]],
+                `[${variableName}] = React.useState(() => ${nodeText})`
+              );
+            };
+          })()
+        });
+      }
+    };
+  })
+});
+
+// node_modules/.pnpm/@tanstack+eslint-plugin-query@5.61.3_eslint@9.15.0_jiti@2.4.0__typescript@5.7.2/node_modules/@tanstack/eslint-plugin-query/dist/esm/rules/no-rest-destructuring/no-rest-destructuring.rule.js
+init_esm_shims();
+var import_utils7 = __toESM(require_dist(), 1);
+
+// node_modules/.pnpm/@tanstack+eslint-plugin-query@5.61.3_eslint@9.15.0_jiti@2.4.0__typescript@5.7.2/node_modules/@tanstack/eslint-plugin-query/dist/esm/rules/no-rest-destructuring/no-rest-destructuring.utils.js
+init_esm_shims();
+var import_utils6 = __toESM(require_dist(), 1);
+var NoRestDestructuringUtils = {
+  isObjectRestDestructuring(node) {
+    if (node.type !== import_utils6.AST_NODE_TYPES.ObjectPattern) {
+      return false;
+    }
+    return node.properties.some((p) => p.type === import_utils6.AST_NODE_TYPES.RestElement);
+  }
+};
+
+// node_modules/.pnpm/@tanstack+eslint-plugin-query@5.61.3_eslint@9.15.0_jiti@2.4.0__typescript@5.7.2/node_modules/@tanstack/eslint-plugin-query/dist/esm/rules/no-rest-destructuring/no-rest-destructuring.rule.js
+var name3 = "no-rest-destructuring";
+var queryHooks = [
+  "useQuery",
+  "useQueries",
+  "useInfiniteQuery",
+  "useSuspenseQuery",
+  "useSuspenseQueries",
+  "useSuspenseInfiniteQuery"
+];
+var createRule3 = import_utils7.ESLintUtils.RuleCreator(getDocsUrl);
+var rule3 = createRule3({
+  name: name3,
+  meta: {
+    type: "problem",
+    docs: {
+      description: "Disallows rest destructuring in queries",
+      recommended: "warn"
+    },
+    messages: {
+      objectRestDestructure: `Object rest destructuring on a query will observe all changes to the query, leading to excessive re-renders.`
+    },
+    schema: []
+  },
+  defaultOptions: [],
+  create: detectTanstackQueryImports((context, _, helpers) => {
+    return {
+      CallExpression: (node) => {
+        if (!ASTUtils.isIdentifierWithOneOfNames(node.callee, queryHooks) || !helpers.isTanstackQueryImport(node.callee) || node.parent.type !== import_utils7.AST_NODE_TYPES.VariableDeclarator) {
+          return;
+        }
+        const returnValue = node.parent.id;
+        if (node.callee.name !== "useQueries" && node.callee.name !== "useSuspenseQueries") {
+          if (NoRestDestructuringUtils.isObjectRestDestructuring(returnValue)) {
+            context.report({
+              node: node.parent,
+              messageId: "objectRestDestructure"
+            });
+          }
+          return;
+        }
+        if (returnValue.type !== import_utils7.AST_NODE_TYPES.ArrayPattern) {
+          return;
+        }
+        returnValue.elements.forEach((queryResult) => {
+          if (queryResult === null) {
+            return;
+          }
+          if (NoRestDestructuringUtils.isObjectRestDestructuring(queryResult)) {
+            context.report({
+              node: queryResult,
+              messageId: "objectRestDestructure"
+            });
+          }
+        });
+      }
+    };
+  })
+});
+
+// node_modules/.pnpm/@tanstack+eslint-plugin-query@5.61.3_eslint@9.15.0_jiti@2.4.0__typescript@5.7.2/node_modules/@tanstack/eslint-plugin-query/dist/esm/rules/no-unstable-deps/no-unstable-deps.rule.js
+init_esm_shims();
+var import_utils8 = __toESM(require_dist(), 1);
+var name4 = "no-unstable-deps";
+var reactHookNames = ["useEffect", "useCallback", "useMemo"];
+var useQueryHookNames = [
+  "useQuery",
+  "useSuspenseQuery",
+  "useQueries",
+  "useSuspenseQueries",
+  "useInfiniteQuery",
+  "useSuspenseInfiniteQuery"
+];
+var allHookNames = ["useMutation", ...useQueryHookNames];
+var createRule4 = import_utils8.ESLintUtils.RuleCreator(getDocsUrl);
+var rule4 = createRule4({
+  name: name4,
+  meta: {
+    type: "problem",
+    docs: {
+      description: "Disallow putting the result of query hooks directly in a React hook dependency array",
+      recommended: "error"
+    },
+    messages: {
+      noUnstableDeps: `The result of {{queryHook}} is not referentially stable, so don't pass it directly into the dependencies array of {{reactHook}}. Instead, destructure the return value of {{queryHook}} and pass the destructured values into the dependency array of {{reactHook}}.`
+    },
+    schema: []
+  },
+  defaultOptions: [],
+  create: detectTanstackQueryImports((context) => {
+    const trackedVariables = {};
+    const hookAliasMap = {};
+    function getReactHook(node) {
+      if (node.callee.type === "Identifier") {
+        const calleeName = node.callee.name;
+        if (reactHookNames.includes(calleeName) || calleeName in hookAliasMap) {
+          return calleeName;
+        }
+      } else if (node.callee.type === "MemberExpression" && node.callee.object.type === "Identifier" && node.callee.object.name === "React" && node.callee.property.type === "Identifier" && reactHookNames.includes(node.callee.property.name)) {
+        return node.callee.property.name;
+      }
+      return void 0;
+    }
+    function collectVariableNames(pattern, queryHook) {
+      if (pattern.type === import_utils8.AST_NODE_TYPES.Identifier) {
+        trackedVariables[pattern.name] = queryHook;
+      }
+    }
+    return {
+      ImportDeclaration(node) {
+        if (node.specifiers.length > 0 && node.importKind === "value" && node.source.value === "React") {
+          node.specifiers.forEach((specifier) => {
+            if (specifier.type === import_utils8.AST_NODE_TYPES.ImportSpecifier && specifier.imported.type === import_utils8.AST_NODE_TYPES.Identifier && reactHookNames.includes(specifier.imported.name)) {
+              hookAliasMap[specifier.local.name] = specifier.imported.name;
+            }
+          });
+        }
+      },
+      VariableDeclarator(node) {
+        if (node.init !== null && node.init.type === import_utils8.AST_NODE_TYPES.CallExpression && node.init.callee.type === import_utils8.AST_NODE_TYPES.Identifier && allHookNames.includes(node.init.callee.name)) {
+          collectVariableNames(node.id, node.init.callee.name);
+        }
+      },
+      CallExpression: (node) => {
+        var _a;
+        const reactHook = getReactHook(node);
+        if (reactHook !== void 0 && node.arguments.length > 1 && ((_a = node.arguments[1]) == null ? void 0 : _a.type) === import_utils8.AST_NODE_TYPES.ArrayExpression) {
+          const depsArray = node.arguments[1].elements;
+          depsArray.forEach((dep) => {
+            if (dep !== null && dep.type === import_utils8.AST_NODE_TYPES.Identifier && trackedVariables[dep.name] !== void 0) {
+              const queryHook = trackedVariables[dep.name];
+              context.report({
+                node: dep,
+                messageId: "noUnstableDeps",
+                data: {
+                  queryHook,
+                  reactHook
+                }
+              });
+            }
+          });
+        }
+      }
+    };
+  })
+});
+
+// node_modules/.pnpm/@tanstack+eslint-plugin-query@5.61.3_eslint@9.15.0_jiti@2.4.0__typescript@5.7.2/node_modules/@tanstack/eslint-plugin-query/dist/esm/rules/infinite-query-property-order/infinite-query-property-order.rule.js
+init_esm_shims();
+var import_utils9 = __toESM(require_dist(), 1);
+
+// node_modules/.pnpm/@tanstack+eslint-plugin-query@5.61.3_eslint@9.15.0_jiti@2.4.0__typescript@5.7.2/node_modules/@tanstack/eslint-plugin-query/dist/esm/rules/infinite-query-property-order/infinite-query-property-order.utils.js
+init_esm_shims();
+function sortDataByOrder(data, orderRules, key) {
+  const getSubsetIndex = (item, subsets) => {
+    var _a;
+    for (let i = 0; i < subsets.length; i++) {
+      if ((_a = subsets[i]) == null ? void 0 : _a.includes(item)) {
+        return i;
+      }
+    }
+    return null;
+  };
+  const orderSets = orderRules.reduce(
+    (sets, [A, B]) => [...sets, A, B],
+    []
+  );
+  const inOrderArray = data.filter(
+    (item) => getSubsetIndex(item[key], orderSets) !== null
+  );
+  let wasResorted = false;
+  const sortedArray = inOrderArray.sort((a, b) => {
+    const aKey = a[key], bKey = b[key];
+    const aSubsetIndex = getSubsetIndex(aKey, orderSets);
+    const bSubsetIndex = getSubsetIndex(bKey, orderSets);
+    if (aSubsetIndex !== null && bSubsetIndex !== null && aSubsetIndex !== bSubsetIndex) {
+      return aSubsetIndex - bSubsetIndex;
+    }
+    return 0;
+  });
+  const inOrderIterator = sortedArray.values();
+  const result = data.map((item) => {
+    if (getSubsetIndex(item[key], orderSets) !== null) {
+      const sortedItem = inOrderIterator.next().value;
+      if (sortedItem[key] !== item[key]) {
+        wasResorted = true;
+      }
+      return sortedItem;
+    }
+    return item;
+  });
+  if (!wasResorted) {
+    return null;
+  }
+  return result;
+}
+
+// node_modules/.pnpm/@tanstack+eslint-plugin-query@5.61.3_eslint@9.15.0_jiti@2.4.0__typescript@5.7.2/node_modules/@tanstack/eslint-plugin-query/dist/esm/rules/infinite-query-property-order/constants.js
+init_esm_shims();
+var infiniteQueryFunctions = [
+  "infiniteQueryOptions",
+  "useInfiniteQuery",
+  "useSuspenseInfiniteQuery"
+];
+var sortRules = [
+  [["queryFn"], ["getPreviousPageParam", "getNextPageParam"]]
+];
+
+// node_modules/.pnpm/@tanstack+eslint-plugin-query@5.61.3_eslint@9.15.0_jiti@2.4.0__typescript@5.7.2/node_modules/@tanstack/eslint-plugin-query/dist/esm/rules/infinite-query-property-order/infinite-query-property-order.rule.js
+var createRule5 = import_utils9.ESLintUtils.RuleCreator(getDocsUrl);
+var infiniteQueryFunctionsSet = new Set(infiniteQueryFunctions);
+function isInfiniteQueryFunction(node) {
+  return infiniteQueryFunctionsSet.has(node);
+}
+var name5 = "infinite-query-property-order";
+var rule5 = createRule5({
+  name: name5,
+  meta: {
+    type: "problem",
+    docs: {
+      description: "Ensure correct order of inference sensitive properties for infinite queries",
+      recommended: "error"
+    },
+    messages: {
+      invalidOrder: "Invalid order of properties for `{{function}}`."
+    },
+    schema: [],
+    hasSuggestions: true,
+    fixable: "code"
+  },
+  defaultOptions: [],
+  create: detectTanstackQueryImports((context) => {
+    return {
+      CallExpression(node) {
+        if (node.callee.type !== import_utils9.AST_NODE_TYPES.Identifier) {
+          return;
+        }
+        const infiniteQueryFunction = node.callee.name;
+        if (!isInfiniteQueryFunction(infiniteQueryFunction)) {
+          return;
+        }
+        const argument = node.arguments[0];
+        if (argument === void 0 || argument.type !== "ObjectExpression") {
+          return;
+        }
+        const allProperties = argument.properties;
+        if (allProperties.length < 2) {
+          return;
+        }
+        const properties = allProperties.flatMap((p, index) => {
+          if (p.type === import_utils9.AST_NODE_TYPES.Property && p.key.type === import_utils9.AST_NODE_TYPES.Identifier) {
+            return { name: p.key.name, property: p };
+          } else return { name: `_property_${index}`, property: p };
+        });
+        const sortedProperties = sortDataByOrder(properties, sortRules, "name");
+        if (sortedProperties === null) {
+          return;
+        }
+        context.report({
+          node: argument,
+          data: { function: node.callee.name },
+          messageId: "invalidOrder",
+          fix(fixer) {
+            const sourceCode = context.sourceCode;
+            const reorderedText = sortedProperties.reduce(
+              (sourceText, specifier, index) => {
+                let textBetweenProperties = "";
+                if (index < allProperties.length - 1) {
+                  textBetweenProperties = sourceCode.getText().slice(
+                    allProperties[index].range[1],
+                    allProperties[index + 1].range[0]
+                  );
+                }
+                return sourceText + sourceCode.getText(specifier.property) + textBetweenProperties;
+              },
+              ""
+            );
+            return fixer.replaceTextRange(
+              [allProperties[0].range[0], allProperties.at(-1).range[1]],
+              reorderedText
+            );
+          }
+        });
+      }
+    };
+  })
+});
+
+// node_modules/.pnpm/@tanstack+eslint-plugin-query@5.61.3_eslint@9.15.0_jiti@2.4.0__typescript@5.7.2/node_modules/@tanstack/eslint-plugin-query/dist/esm/rules.js
+var rules = {
+  [name]: rule,
+  [name2]: rule2,
+  [name3]: rule3,
+  [name4]: rule4,
+  [name5]: rule5
+};
+
+// node_modules/.pnpm/@tanstack+eslint-plugin-query@5.61.3_eslint@9.15.0_jiti@2.4.0__typescript@5.7.2/node_modules/@tanstack/eslint-plugin-query/dist/esm/index.js
+var plugin = {
+  meta: {
+    name: "@tanstack/eslint-plugin-query"
+  },
+  configs: {},
+  rules
+};
+Object.assign(plugin.configs, {
+  recommended: {
+    plugins: ["@tanstack/query"],
+    rules: {
+      "@tanstack/query/exhaustive-deps": "error",
+      "@tanstack/query/no-rest-destructuring": "warn",
+      "@tanstack/query/stable-query-client": "error",
+      "@tanstack/query/no-unstable-deps": "error",
+      "@tanstack/query/infinite-query-property-order": "error"
+    }
+  },
+  "flat/recommended": [
+    {
+      plugins: {
+        "@tanstack/query": plugin
+      },
+      rules: {
+        "@tanstack/query/exhaustive-deps": "error",
+        "@tanstack/query/no-rest-destructuring": "warn",
+        "@tanstack/query/stable-query-client": "error",
+        "@tanstack/query/no-unstable-deps": "error",
+        "@tanstack/query/infinite-query-property-order": "error"
+      }
+    }
+  ]
+});
+
+// src/configs/react.ts
+function reactOverrides() {
+  return {
+    overrides: {}
+  };
+}
+function reactPlugins(options) {
+  return options?.react ? [
+    ...plugin.configs["flat/recommended"]
+  ] : [];
+}
+
+// src/configs/typescript.ts
+init_esm_shims();
+function typescript(options = {}) {
+  const { overrides = {} } = options;
+  return {
+    ...options,
+    overrides: {
+      "ts/array-type": [
+        "error",
+        {
+          default: "generic"
+        }
+      ],
+      "ts/explicit-member-accessibility": [
+        "error",
+        {
+          accessibility: "explicit"
+        }
+      ],
+      "ts/no-redeclare": "off",
+      "ts/no-use-before-define": "off",
+      ...overrides
+    }
+  };
+}
+
+// src/options.ts
+function oncourseOptions(options) {
+  return {
+    formatters: {
+      css: true,
+      html: true,
+      markdown: true
+    },
+    lessOpinionated: true,
+    name: "oncourse",
+    react: options?.react ? reactOverrides() : false,
+    ...reactPlugins(options),
+    stylistic: {
+      indent: 2,
+      quotes: "single",
+      semi: true
+    },
+    typescript: typescript()
+  };
+}
+
+// src/index.ts
+export * from "@antfu/eslint-config";
+function oncourse(options, ...configs) {
+  return antfu(
+    {
+      ...oncourseOptions(options),
+      ...options
+    },
+    ...oncourseConfigs(options),
+    ...configs
+  );
+}
+var src_default = oncourse;
+export {
+  src_default as default
+};