corsa-oxlint 0.1.0

package/dist/rules/prefer_includes.js

@@ -0,0 +1,21 @@
+import { calleePropertyName, isNegativeOneLiteral, isZeroLiteral } from "./ast.js";
+import { createNativeRule } from "./rule_creator.js";
+//#region src/bindings/nodejs/typescript_oxlint/ts/rules/prefer_includes.ts
+const preferIncludesRule = createNativeRule("prefer-includes", {
+	docs: { description: "Prefer includes over indexOf/lastIndexOf comparisons." },
+	messages: { unexpected: "Use .includes() instead of comparing an index result." }
+}, (context) => ({ BinaryExpression(node) {
+	if (!isComparableIndexSearch(node.left) && !isComparableIndexSearch(node.right)) return;
+	if (isNegativeOneLiteral(node.left) || isNegativeOneLiteral(node.right) || isZeroLiteral(node.left) || isZeroLiteral(node.right)) context.report({
+		node,
+		messageId: "unexpected"
+	});
+} }));
+function isComparableIndexSearch(node) {
+	const propertyName = calleePropertyName(node);
+	return propertyName === "indexOf" || propertyName === "lastIndexOf";
+}
+//#endregion
+export { preferIncludesRule };
+
+//# sourceMappingURL=prefer_includes.js.map

package/dist/rules/prefer_includes.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"prefer_includes.js","names":[],"sources":["../../ts/rules/prefer_includes.ts"],"sourcesContent":["import { calleePropertyName, isNegativeOneLiteral, isZeroLiteral } from \"./ast\";\nimport { createNativeRule } from \"./rule_creator\";\n\nexport const preferIncludesRule = createNativeRule(\n  \"prefer-includes\",\n  {\n    docs: {\n      description: \"Prefer includes over indexOf/lastIndexOf comparisons.\",\n    },\n    messages: {\n      unexpected: \"Use .includes() instead of comparing an index result.\",\n    },\n  },\n  (context) => ({\n    BinaryExpression(node: any) {\n      if (!isComparableIndexSearch(node.left) && !isComparableIndexSearch(node.right)) {\n        return;\n      }\n      if (\n        isNegativeOneLiteral(node.left) ||\n        isNegativeOneLiteral(node.right) ||\n        isZeroLiteral(node.left) ||\n        isZeroLiteral(node.right)\n      ) {\n        context.report({ node, messageId: \"unexpected\" });\n      }\n    },\n  }),\n);\n\nfunction isComparableIndexSearch(node: any): boolean {\n  const propertyName = calleePropertyName(node);\n  return propertyName === \"indexOf\" || propertyName === \"lastIndexOf\";\n}\n"],"mappings":";;;AAGA,MAAa,qBAAqB,iBAChC,mBACA;CACE,MAAM,EACJ,aAAa,yDACd;CACD,UAAU,EACR,YAAY,yDACb;CACF,GACA,aAAa,EACZ,iBAAiB,MAAW;AAC1B,KAAI,CAAC,wBAAwB,KAAK,KAAK,IAAI,CAAC,wBAAwB,KAAK,MAAM,CAC7E;AAEF,KACE,qBAAqB,KAAK,KAAK,IAC/B,qBAAqB,KAAK,MAAM,IAChC,cAAc,KAAK,KAAK,IACxB,cAAc,KAAK,MAAM,CAEzB,SAAQ,OAAO;EAAE;EAAM,WAAW;EAAc,CAAC;GAGtD,EACF;AAED,SAAS,wBAAwB,MAAoB;CACnD,MAAM,eAAe,mBAAmB,KAAK;AAC7C,QAAO,iBAAiB,aAAa,iBAAiB"}

package/dist/rules/prefer_promise_reject_errors.d.ts

@@ -0,0 +1,16 @@
+//#region src/bindings/nodejs/typescript_oxlint/ts/rules/prefer_promise_reject_errors.d.ts
+declare const preferPromiseRejectErrorsRule: {
+  defaultOptions: never[];
+  meta: {
+    docs: {
+      requiresTypeChecking: boolean;
+      url: string;
+    };
+    type: "problem";
+    schema: never[];
+  };
+  create: (context: any) => Record<string, (node: any) => void>;
+};
+//#endregion
+export { preferPromiseRejectErrorsRule };
+//# sourceMappingURL=prefer_promise_reject_errors.d.ts.map

package/dist/rules/prefer_promise_reject_errors.js

@@ -0,0 +1,52 @@
+import { isIdentifierNamed, memberObject, memberPropertyName, nearestFunctionAncestors, stripChainExpression } from "./ast.js";
+import { createNativeRule } from "./rule_creator.js";
+import { isAnyLikeNode, isErrorLikeNode, isPromiseLikeNode, isUnknownLikeNode } from "./type_utils.js";
+//#region src/bindings/nodejs/typescript_oxlint/ts/rules/prefer_promise_reject_errors.ts
+const defaults = {
+	allowEmptyReject: false,
+	allowThrowingAny: false,
+	allowThrowingUnknown: false
+};
+const preferPromiseRejectErrorsRule = createNativeRule("prefer-promise-reject-errors", {
+	docs: { description: "Require Promise rejection reasons to be Error-like values." },
+	messages: { rejectAnError: "Expected the Promise rejection reason to be an Error." },
+	schema: { type: "array" }
+}, (context) => ({ CallExpression(node) {
+	if (!isPromiseRejectCall(context, node) && !isPromiseExecutorRejectCall(context, node)) return;
+	if (acceptRejectArguments(context, node.arguments, resolveOptions(context.options))) return;
+	context.report({
+		node,
+		messageId: "rejectAnError"
+	});
+} }));
+function isPromiseRejectCall(context, node) {
+	const object = memberObject(node.callee);
+	return memberPropertyName(node.callee) === "reject" && (isIdentifierNamed(object, "Promise") || isPromiseLikeNode(context, object));
+}
+function isPromiseExecutorRejectCall(context, node) {
+	const callee = stripChainExpression(node.callee);
+	if (callee?.type !== "Identifier") return false;
+	const [nearestFunction] = nearestFunctionAncestors(node, context.sourceCode);
+	if (!nearestFunction) return false;
+	const rejectParam = nearestFunction.params?.[1];
+	if (!rejectParam || rejectParam.type !== "Identifier" || rejectParam.name !== callee.name) return false;
+	const promiseConstructor = stripChainExpression(nearestFunction.parent?.parent);
+	return nearestFunction.parent?.type === "NewExpression" && isIdentifierNamed(nearestFunction.parent.callee, "Promise") || promiseConstructor?.type === "NewExpression" && isIdentifierNamed(promiseConstructor.callee, "Promise");
+}
+function acceptRejectArguments(context, args, options) {
+	const [argument] = args;
+	if (!argument) return options.allowEmptyReject;
+	if (options.allowThrowingAny && isAnyLikeNode(context, argument)) return true;
+	if (options.allowThrowingUnknown && isUnknownLikeNode(context, argument)) return true;
+	return isErrorLikeNode(context, argument);
+}
+function resolveOptions(options) {
+	return {
+		...defaults,
+		...options[0]
+	};
+}
+//#endregion
+export { preferPromiseRejectErrorsRule };
+
+//# sourceMappingURL=prefer_promise_reject_errors.js.map

package/dist/rules/prefer_promise_reject_errors.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"prefer_promise_reject_errors.js","names":[],"sources":["../../ts/rules/prefer_promise_reject_errors.ts"],"sourcesContent":["import {\n  isIdentifierNamed,\n  memberObject,\n  memberPropertyName,\n  nearestFunctionAncestors,\n  stripChainExpression,\n} from \"./ast\";\nimport { createNativeRule } from \"./rule_creator\";\nimport { isAnyLikeNode, isErrorLikeNode, isPromiseLikeNode, isUnknownLikeNode } from \"./type_utils\";\n\ntype Options = {\n  allowEmptyReject?: boolean;\n  allowThrowingAny?: boolean;\n  allowThrowingUnknown?: boolean;\n};\n\nconst defaults: Required<Options> = {\n  allowEmptyReject: false,\n  allowThrowingAny: false,\n  allowThrowingUnknown: false,\n};\n\nexport const preferPromiseRejectErrorsRule = createNativeRule(\n  \"prefer-promise-reject-errors\",\n  {\n    docs: {\n      description: \"Require Promise rejection reasons to be Error-like values.\",\n    },\n    messages: {\n      rejectAnError: \"Expected the Promise rejection reason to be an Error.\",\n    },\n    schema: { type: \"array\" },\n  },\n  (context) => ({\n    CallExpression(node: any) {\n      if (!isPromiseRejectCall(context, node) && !isPromiseExecutorRejectCall(context, node)) {\n        return;\n      }\n      if (acceptRejectArguments(context, node.arguments, resolveOptions(context.options))) {\n        return;\n      }\n      context.report({ node, messageId: \"rejectAnError\" });\n    },\n  }),\n);\n\nfunction isPromiseRejectCall(context: any, node: any): boolean {\n  const object = memberObject(node.callee) as any;\n  return (\n    memberPropertyName(node.callee) === \"reject\" &&\n    (isIdentifierNamed(object, \"Promise\") || isPromiseLikeNode(context, object))\n  );\n}\n\nfunction isPromiseExecutorRejectCall(context: any, node: any): boolean {\n  const callee = stripChainExpression(node.callee);\n  if (callee?.type !== \"Identifier\") {\n    return false;\n  }\n  const [nearestFunction] = nearestFunctionAncestors(node, context.sourceCode);\n  if (!nearestFunction) {\n    return false;\n  }\n  const rejectParam = nearestFunction.params?.[1];\n  if (!rejectParam || rejectParam.type !== \"Identifier\" || rejectParam.name !== callee.name) {\n    return false;\n  }\n  const promiseConstructor = stripChainExpression(nearestFunction.parent?.parent);\n  return (\n    (nearestFunction.parent?.type === \"NewExpression\" &&\n      isIdentifierNamed(nearestFunction.parent.callee, \"Promise\")) ||\n    (promiseConstructor?.type === \"NewExpression\" &&\n      isIdentifierNamed(promiseConstructor.callee, \"Promise\"))\n  );\n}\n\nfunction acceptRejectArguments(\n  context: any,\n  args: readonly any[],\n  options: Required<Options>,\n): boolean {\n  const [argument] = args;\n  if (!argument) {\n    return options.allowEmptyReject;\n  }\n  if (options.allowThrowingAny && isAnyLikeNode(context, argument)) {\n    return true;\n  }\n  if (options.allowThrowingUnknown && isUnknownLikeNode(context, argument)) {\n    return true;\n  }\n  return isErrorLikeNode(context, argument);\n}\n\nfunction resolveOptions(options: readonly unknown[]): Required<Options> {\n  return { ...defaults, ...(options[0] as Options | undefined) };\n}\n"],"mappings":";;;;AAgBA,MAAM,WAA8B;CAClC,kBAAkB;CAClB,kBAAkB;CAClB,sBAAsB;CACvB;AAED,MAAa,gCAAgC,iBAC3C,gCACA;CACE,MAAM,EACJ,aAAa,8DACd;CACD,UAAU,EACR,eAAe,yDAChB;CACD,QAAQ,EAAE,MAAM,SAAS;CAC1B,GACA,aAAa,EACZ,eAAe,MAAW;AACxB,KAAI,CAAC,oBAAoB,SAAS,KAAK,IAAI,CAAC,4BAA4B,SAAS,KAAK,CACpF;AAEF,KAAI,sBAAsB,SAAS,KAAK,WAAW,eAAe,QAAQ,QAAQ,CAAC,CACjF;AAEF,SAAQ,OAAO;EAAE;EAAM,WAAW;EAAiB,CAAC;GAEvD,EACF;AAED,SAAS,oBAAoB,SAAc,MAAoB;CAC7D,MAAM,SAAS,aAAa,KAAK,OAAO;AACxC,QACE,mBAAmB,KAAK,OAAO,KAAK,aACnC,kBAAkB,QAAQ,UAAU,IAAI,kBAAkB,SAAS,OAAO;;AAI/E,SAAS,4BAA4B,SAAc,MAAoB;CACrE,MAAM,SAAS,qBAAqB,KAAK,OAAO;AAChD,KAAI,QAAQ,SAAS,aACnB,QAAO;CAET,MAAM,CAAC,mBAAmB,yBAAyB,MAAM,QAAQ,WAAW;AAC5E,KAAI,CAAC,gBACH,QAAO;CAET,MAAM,cAAc,gBAAgB,SAAS;AAC7C,KAAI,CAAC,eAAe,YAAY,SAAS,gBAAgB,YAAY,SAAS,OAAO,KACnF,QAAO;CAET,MAAM,qBAAqB,qBAAqB,gBAAgB,QAAQ,OAAO;AAC/E,QACG,gBAAgB,QAAQ,SAAS,mBAChC,kBAAkB,gBAAgB,OAAO,QAAQ,UAAU,IAC5D,oBAAoB,SAAS,mBAC5B,kBAAkB,mBAAmB,QAAQ,UAAU;;AAI7D,SAAS,sBACP,SACA,MACA,SACS;CACT,MAAM,CAAC,YAAY;AACnB,KAAI,CAAC,SACH,QAAO,QAAQ;AAEjB,KAAI,QAAQ,oBAAoB,cAAc,SAAS,SAAS,CAC9D,QAAO;AAET,KAAI,QAAQ,wBAAwB,kBAAkB,SAAS,SAAS,CACtE,QAAO;AAET,QAAO,gBAAgB,SAAS,SAAS;;AAG3C,SAAS,eAAe,SAAgD;AACtE,QAAO;EAAE,GAAG;EAAU,GAAI,QAAQ;EAA4B"}

package/dist/rules/prefer_regexp_exec.d.ts

@@ -0,0 +1,16 @@
+//#region src/bindings/nodejs/typescript_oxlint/ts/rules/prefer_regexp_exec.d.ts
+declare const preferRegexpExecRule: {
+  defaultOptions: never[];
+  meta: {
+    docs: {
+      requiresTypeChecking: boolean;
+      url: string;
+    };
+    type: "problem";
+    schema: never[];
+  };
+  create: (context: any) => Record<string, (node: any) => void>;
+};
+//#endregion
+export { preferRegexpExecRule };
+//# sourceMappingURL=prefer_regexp_exec.d.ts.map

package/dist/rules/prefer_regexp_exec.js

@@ -0,0 +1,20 @@
+import { calleePropertyName, regexFlags } from "./ast.js";
+import { createNativeRule } from "./rule_creator.js";
+//#region src/bindings/nodejs/typescript_oxlint/ts/rules/prefer_regexp_exec.ts
+const preferRegexpExecRule = createNativeRule("prefer-regexp-exec", {
+	docs: { description: "Prefer RegExp#exec over String#match for single matches." },
+	messages: { unexpected: "Use a RegExp exec() call instead of String match()." }
+}, (context) => ({ CallExpression(node) {
+	if (calleePropertyName(node) !== "match") return;
+	const [firstArgument] = node.arguments;
+	if (!firstArgument) return;
+	const flags = regexFlags(firstArgument);
+	if (flags !== void 0 && !flags.includes("g")) context.report({
+		node,
+		messageId: "unexpected"
+	});
+} }));
+//#endregion
+export { preferRegexpExecRule };
+
+//# sourceMappingURL=prefer_regexp_exec.js.map

package/dist/rules/prefer_regexp_exec.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"prefer_regexp_exec.js","names":[],"sources":["../../ts/rules/prefer_regexp_exec.ts"],"sourcesContent":["import { calleePropertyName, regexFlags } from \"./ast\";\nimport { createNativeRule } from \"./rule_creator\";\n\nexport const preferRegexpExecRule = createNativeRule(\n  \"prefer-regexp-exec\",\n  {\n    docs: {\n      description: \"Prefer RegExp#exec over String#match for single matches.\",\n    },\n    messages: {\n      unexpected: \"Use a RegExp exec() call instead of String match().\",\n    },\n  },\n  (context) => ({\n    CallExpression(node: any) {\n      if (calleePropertyName(node) !== \"match\") {\n        return;\n      }\n      const [firstArgument] = node.arguments;\n      if (!firstArgument) {\n        return;\n      }\n      const flags = regexFlags(firstArgument);\n      if (flags !== undefined && !flags.includes(\"g\")) {\n        context.report({ node, messageId: \"unexpected\" });\n      }\n    },\n  }),\n);\n"],"mappings":";;;AAGA,MAAa,uBAAuB,iBAClC,sBACA;CACE,MAAM,EACJ,aAAa,4DACd;CACD,UAAU,EACR,YAAY,uDACb;CACF,GACA,aAAa,EACZ,eAAe,MAAW;AACxB,KAAI,mBAAmB,KAAK,KAAK,QAC/B;CAEF,MAAM,CAAC,iBAAiB,KAAK;AAC7B,KAAI,CAAC,cACH;CAEF,MAAM,QAAQ,WAAW,cAAc;AACvC,KAAI,UAAU,KAAA,KAAa,CAAC,MAAM,SAAS,IAAI,CAC7C,SAAQ,OAAO;EAAE;EAAM,WAAW;EAAc,CAAC;GAGtD,EACF"}

package/dist/rules/prefer_string_starts_ends_with.d.ts

@@ -0,0 +1,16 @@
+//#region src/bindings/nodejs/typescript_oxlint/ts/rules/prefer_string_starts_ends_with.d.ts
+declare const preferStringStartsEndsWithRule: {
+  defaultOptions: never[];
+  meta: {
+    docs: {
+      requiresTypeChecking: boolean;
+      url: string;
+    };
+    type: "problem";
+    schema: never[];
+  };
+  create: (context: any) => Record<string, (node: any) => void>;
+};
+//#endregion
+export { preferStringStartsEndsWithRule };
+//# sourceMappingURL=prefer_string_starts_ends_with.d.ts.map

package/dist/rules/prefer_string_starts_ends_with.js

@@ -0,0 +1,53 @@
+import { calleePropertyName, isZeroLiteral, memberObject, memberPropertyName, stripChainExpression } from "./ast.js";
+import { createNativeRule } from "./rule_creator.js";
+//#region src/bindings/nodejs/typescript_oxlint/ts/rules/prefer_string_starts_ends_with.ts
+const comparableOperators = new Set([
+	"==",
+	"===",
+	"!=",
+	"!=="
+]);
+const preferStringStartsEndsWithRule = createNativeRule("prefer-string-starts-ends-with", {
+	docs: { description: "Prefer startsWith()/endsWith() over manual string prefix/suffix checks." },
+	messages: {
+		endsWith: "Use endsWith() instead of slicing and comparing a suffix.",
+		startsWith: "Use startsWith() instead of comparing a prefix manually."
+	}
+}, (context) => ({ BinaryExpression(node) {
+	if (!comparableOperators.has(node.operator)) return;
+	const match = detectManualStringCheck(context.sourceCode, node.left, node.right) ?? detectManualStringCheck(context.sourceCode, node.right, node.left);
+	if (!match) return;
+	context.report({
+		node,
+		messageId: match
+	});
+} }));
+function detectManualStringCheck(sourceCode, candidate, compared) {
+	const current = stripChainExpression(candidate);
+	if (current?.type !== "CallExpression") return;
+	if (calleePropertyName(current) === "indexOf" && isZeroLiteral(compared)) return "startsWith";
+	if (calleePropertyName(current) !== "slice") return;
+	const [start, end] = current.arguments;
+	if (isZeroLiteral(start) && end && sameLengthTarget(end, compared, sourceCode)) return "startsWith";
+	const suffix = negativeLengthTarget(start);
+	if (!end && suffix && sameExpression(suffix, compared, sourceCode)) return "endsWith";
+}
+function sameLengthTarget(lengthNode, compared, sourceCode) {
+	if (memberPropertyName(lengthNode) !== "length") return false;
+	const target = memberObject(lengthNode);
+	return target ? sameExpression(target, compared, sourceCode) : false;
+}
+function negativeLengthTarget(node) {
+	const current = stripChainExpression(node);
+	if (current?.type !== "UnaryExpression" || current.operator !== "-") return;
+	const target = memberObject(current.argument);
+	if (!target || memberPropertyName(current.argument) !== "length") return;
+	return target;
+}
+function sameExpression(left, right, sourceCode) {
+	return sourceCode.getText(stripChainExpression(left)) === sourceCode.getText(stripChainExpression(right));
+}
+//#endregion
+export { preferStringStartsEndsWithRule };
+
+//# sourceMappingURL=prefer_string_starts_ends_with.js.map

package/dist/rules/prefer_string_starts_ends_with.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"prefer_string_starts_ends_with.js","names":[],"sources":["../../ts/rules/prefer_string_starts_ends_with.ts"],"sourcesContent":["import {\n  calleePropertyName,\n  isZeroLiteral,\n  memberObject,\n  memberPropertyName,\n  stripChainExpression,\n} from \"./ast\";\nimport { createNativeRule } from \"./rule_creator\";\n\nconst comparableOperators = new Set([\"==\", \"===\", \"!=\", \"!==\"]);\n\nexport const preferStringStartsEndsWithRule = createNativeRule(\n  \"prefer-string-starts-ends-with\",\n  {\n    docs: {\n      description: \"Prefer startsWith()/endsWith() over manual string prefix/suffix checks.\",\n    },\n    messages: {\n      endsWith: \"Use endsWith() instead of slicing and comparing a suffix.\",\n      startsWith: \"Use startsWith() instead of comparing a prefix manually.\",\n    },\n  },\n  (context) => ({\n    BinaryExpression(node: any) {\n      if (!comparableOperators.has(node.operator)) {\n        return;\n      }\n\n      const match =\n        detectManualStringCheck(context.sourceCode, node.left, node.right) ??\n        detectManualStringCheck(context.sourceCode, node.right, node.left);\n      if (!match) {\n        return;\n      }\n\n      context.report({\n        node,\n        messageId: match,\n      });\n    },\n  }),\n);\n\nfunction detectManualStringCheck(\n  sourceCode: any,\n  candidate: any,\n  compared: any,\n): \"startsWith\" | \"endsWith\" | undefined {\n  const current = stripChainExpression(candidate) as any;\n  if (current?.type !== \"CallExpression\") {\n    return undefined;\n  }\n\n  if (calleePropertyName(current) === \"indexOf\" && isZeroLiteral(compared)) {\n    return \"startsWith\";\n  }\n\n  if (calleePropertyName(current) !== \"slice\") {\n    return undefined;\n  }\n\n  const [start, end] = current.arguments;\n  if (isZeroLiteral(start) && end && sameLengthTarget(end, compared, sourceCode)) {\n    return \"startsWith\";\n  }\n\n  const suffix = negativeLengthTarget(start);\n  if (!end && suffix && sameExpression(suffix, compared, sourceCode)) {\n    return \"endsWith\";\n  }\n\n  return undefined;\n}\n\nfunction sameLengthTarget(lengthNode: any, compared: any, sourceCode: any): boolean {\n  if (memberPropertyName(lengthNode) !== \"length\") {\n    return false;\n  }\n  const target = memberObject(lengthNode);\n  return target ? sameExpression(target, compared, sourceCode) : false;\n}\n\nfunction negativeLengthTarget(node: any): any {\n  const current = stripChainExpression(node) as any;\n  if (current?.type !== \"UnaryExpression\" || current.operator !== \"-\") {\n    return undefined;\n  }\n  const target = memberObject(current.argument);\n  if (!target || memberPropertyName(current.argument) !== \"length\") {\n    return undefined;\n  }\n  return target;\n}\n\nfunction sameExpression(left: any, right: any, sourceCode: any): boolean {\n  return (\n    sourceCode.getText(stripChainExpression(left)) ===\n    sourceCode.getText(stripChainExpression(right))\n  );\n}\n"],"mappings":";;;AASA,MAAM,sBAAsB,IAAI,IAAI;CAAC;CAAM;CAAO;CAAM;CAAM,CAAC;AAE/D,MAAa,iCAAiC,iBAC5C,kCACA;CACE,MAAM,EACJ,aAAa,2EACd;CACD,UAAU;EACR,UAAU;EACV,YAAY;EACb;CACF,GACA,aAAa,EACZ,iBAAiB,MAAW;AAC1B,KAAI,CAAC,oBAAoB,IAAI,KAAK,SAAS,CACzC;CAGF,MAAM,QACJ,wBAAwB,QAAQ,YAAY,KAAK,MAAM,KAAK,MAAM,IAClE,wBAAwB,QAAQ,YAAY,KAAK,OAAO,KAAK,KAAK;AACpE,KAAI,CAAC,MACH;AAGF,SAAQ,OAAO;EACb;EACA,WAAW;EACZ,CAAC;GAEL,EACF;AAED,SAAS,wBACP,YACA,WACA,UACuC;CACvC,MAAM,UAAU,qBAAqB,UAAU;AAC/C,KAAI,SAAS,SAAS,iBACpB;AAGF,KAAI,mBAAmB,QAAQ,KAAK,aAAa,cAAc,SAAS,CACtE,QAAO;AAGT,KAAI,mBAAmB,QAAQ,KAAK,QAClC;CAGF,MAAM,CAAC,OAAO,OAAO,QAAQ;AAC7B,KAAI,cAAc,MAAM,IAAI,OAAO,iBAAiB,KAAK,UAAU,WAAW,CAC5E,QAAO;CAGT,MAAM,SAAS,qBAAqB,MAAM;AAC1C,KAAI,CAAC,OAAO,UAAU,eAAe,QAAQ,UAAU,WAAW,CAChE,QAAO;;AAMX,SAAS,iBAAiB,YAAiB,UAAe,YAA0B;AAClF,KAAI,mBAAmB,WAAW,KAAK,SACrC,QAAO;CAET,MAAM,SAAS,aAAa,WAAW;AACvC,QAAO,SAAS,eAAe,QAAQ,UAAU,WAAW,GAAG;;AAGjE,SAAS,qBAAqB,MAAgB;CAC5C,MAAM,UAAU,qBAAqB,KAAK;AAC1C,KAAI,SAAS,SAAS,qBAAqB,QAAQ,aAAa,IAC9D;CAEF,MAAM,SAAS,aAAa,QAAQ,SAAS;AAC7C,KAAI,CAAC,UAAU,mBAAmB,QAAQ,SAAS,KAAK,SACtD;AAEF,QAAO;;AAGT,SAAS,eAAe,MAAW,OAAY,YAA0B;AACvE,QACE,WAAW,QAAQ,qBAAqB,KAAK,CAAC,KAC9C,WAAW,QAAQ,qBAAqB,MAAM,CAAC"}

package/dist/rules/require_array_sort_compare.d.ts

@@ -0,0 +1,16 @@
+//#region src/bindings/nodejs/typescript_oxlint/ts/rules/require_array_sort_compare.d.ts
+declare const requireArraySortCompareRule: {
+  defaultOptions: never[];
+  meta: {
+    docs: {
+      requiresTypeChecking: boolean;
+      url: string;
+    };
+    type: "problem";
+    schema: never[];
+  };
+  create: (context: any) => Record<string, (node: any) => void>;
+};
+//#endregion
+export { requireArraySortCompareRule };
+//# sourceMappingURL=require_array_sort_compare.d.ts.map

package/dist/rules/require_array_sort_compare.js

@@ -0,0 +1,36 @@
+import { memberObject, memberPropertyName } from "./ast.js";
+import { createNativeRule } from "./rule_creator.js";
+import { isArrayLikeNode, typeTextsAtNode } from "./type_utils.js";
+//#region src/bindings/nodejs/typescript_oxlint/ts/rules/require_array_sort_compare.ts
+const defaults = { ignoreStringArrays: true };
+const requireArraySortCompareRule = createNativeRule("require-array-sort-compare", {
+	docs: { description: "Require compare callbacks for array sorting calls." },
+	messages: { requireCompare: "Require a compare argument for array sorting." },
+	schema: { type: "array" }
+}, (context) => ({ CallExpression(node) {
+	if (node.arguments.length !== 0) return;
+	const methodName = memberPropertyName(node.callee);
+	if (methodName !== "sort" && methodName !== "toSorted") return;
+	const object = memberObject(node.callee);
+	if (!object || !isArrayLikeNode(context, object)) return;
+	if (resolveOptions(context.options).ignoreStringArrays && isStringArrayLike(context, object)) return;
+	context.report({
+		node,
+		messageId: "requireCompare"
+	});
+} }));
+function isStringArrayLike(context, node) {
+	return typeTextsAtNode(context, node).some((text) => {
+		return text === "string[]" || text === "readonly string[]" || text.startsWith("Array<string>") || text.startsWith("ReadonlyArray<string>");
+	});
+}
+function resolveOptions(options) {
+	return {
+		...defaults,
+		...options[0]
+	};
+}
+//#endregion
+export { requireArraySortCompareRule };
+
+//# sourceMappingURL=require_array_sort_compare.js.map

package/dist/rules/require_array_sort_compare.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"require_array_sort_compare.js","names":[],"sources":["../../ts/rules/require_array_sort_compare.ts"],"sourcesContent":["import { memberObject, memberPropertyName } from \"./ast\";\nimport { createNativeRule } from \"./rule_creator\";\nimport { isArrayLikeNode, typeTextsAtNode } from \"./type_utils\";\n\ntype Options = {\n  ignoreStringArrays?: boolean;\n};\n\nconst defaults: Required<Options> = {\n  ignoreStringArrays: true,\n};\n\nexport const requireArraySortCompareRule = createNativeRule(\n  \"require-array-sort-compare\",\n  {\n    docs: {\n      description: \"Require compare callbacks for array sorting calls.\",\n    },\n    messages: {\n      requireCompare: \"Require a compare argument for array sorting.\",\n    },\n    schema: { type: \"array\" },\n  },\n  (context) => ({\n    CallExpression(node: any) {\n      if (node.arguments.length !== 0) {\n        return;\n      }\n      const methodName = memberPropertyName(node.callee);\n      if (methodName !== \"sort\" && methodName !== \"toSorted\") {\n        return;\n      }\n      const object = memberObject(node.callee) as any;\n      if (!object || !isArrayLikeNode(context, object)) {\n        return;\n      }\n      if (\n        resolveOptions(context.options).ignoreStringArrays &&\n        isStringArrayLike(context, object)\n      ) {\n        return;\n      }\n      context.report({ node, messageId: \"requireCompare\" });\n    },\n  }),\n);\n\nfunction isStringArrayLike(context: any, node: any): boolean {\n  return typeTextsAtNode(context, node).some((text) => {\n    return (\n      text === \"string[]\" ||\n      text === \"readonly string[]\" ||\n      text.startsWith(\"Array<string>\") ||\n      text.startsWith(\"ReadonlyArray<string>\")\n    );\n  });\n}\n\nfunction resolveOptions(options: readonly unknown[]): Required<Options> {\n  return { ...defaults, ...(options[0] as Options | undefined) };\n}\n"],"mappings":";;;;AAQA,MAAM,WAA8B,EAClC,oBAAoB,MACrB;AAED,MAAa,8BAA8B,iBACzC,8BACA;CACE,MAAM,EACJ,aAAa,sDACd;CACD,UAAU,EACR,gBAAgB,iDACjB;CACD,QAAQ,EAAE,MAAM,SAAS;CAC1B,GACA,aAAa,EACZ,eAAe,MAAW;AACxB,KAAI,KAAK,UAAU,WAAW,EAC5B;CAEF,MAAM,aAAa,mBAAmB,KAAK,OAAO;AAClD,KAAI,eAAe,UAAU,eAAe,WAC1C;CAEF,MAAM,SAAS,aAAa,KAAK,OAAO;AACxC,KAAI,CAAC,UAAU,CAAC,gBAAgB,SAAS,OAAO,CAC9C;AAEF,KACE,eAAe,QAAQ,QAAQ,CAAC,sBAChC,kBAAkB,SAAS,OAAO,CAElC;AAEF,SAAQ,OAAO;EAAE;EAAM,WAAW;EAAkB,CAAC;GAExD,EACF;AAED,SAAS,kBAAkB,SAAc,MAAoB;AAC3D,QAAO,gBAAgB,SAAS,KAAK,CAAC,MAAM,SAAS;AACnD,SACE,SAAS,cACT,SAAS,uBACT,KAAK,WAAW,gBAAgB,IAChC,KAAK,WAAW,wBAAwB;GAE1C;;AAGJ,SAAS,eAAe,SAAgD;AACtE,QAAO;EAAE,GAAG;EAAU,GAAI,QAAQ;EAA4B"}

package/dist/rules/restrict_plus_operands.d.ts

@@ -0,0 +1,16 @@
+//#region src/bindings/nodejs/typescript_oxlint/ts/rules/restrict_plus_operands.d.ts
+declare const restrictPlusOperandsRule: {
+  defaultOptions: never[];
+  meta: {
+    docs: {
+      requiresTypeChecking: boolean;
+      url: string;
+    };
+    type: "problem";
+    schema: never[];
+  };
+  create: (context: any) => Record<string, (node: any) => void>;
+};
+//#endregion
+export { restrictPlusOperandsRule };
+//# sourceMappingURL=restrict_plus_operands.d.ts.map

package/dist/rules/restrict_plus_operands.js

@@ -0,0 +1,62 @@
+import { createNativeRule } from "./rule_creator.js";
+import { classifyTypeText, typeTextAtNode } from "./type_utils.js";
+//#region src/bindings/nodejs/typescript_oxlint/ts/rules/restrict_plus_operands.ts
+const defaults = {
+	allowAny: true,
+	allowBoolean: true,
+	allowNullish: true,
+	allowNumberAndString: true,
+	allowRegExp: false,
+	skipCompoundAssignments: false
+};
+const restrictPlusOperandsRule = createNativeRule("restrict-plus-operands", {
+	docs: { description: "Require plus operands to be explicitly compatible." },
+	messages: {
+		invalid: "Operands of + must be compatible primitive values.",
+		mismatched: "Operands of + operations must be of the same type."
+	},
+	schema: { type: "array" }
+}, (context) => ({
+	AssignmentExpression(node) {
+		const options = resolveOptions(context.options);
+		if (options.skipCompoundAssignments || node.operator !== "+=") return;
+		reportIfInvalid(context, node, node.left, node.right, options);
+	},
+	BinaryExpression(node) {
+		if (node.operator !== "+") return;
+		reportIfInvalid(context, node, node.left, node.right, resolveOptions(context.options));
+	}
+}));
+function reportIfInvalid(context, node, left, right, options) {
+	const leftKind = classifyTypeText(typeTextAtNode(context, left));
+	const rightKind = classifyTypeText(typeTextAtNode(context, right));
+	if (isAllowed(leftKind, rightKind, options)) return;
+	context.report({
+		node,
+		messageId: leftKind === "other" || rightKind === "other" || leftKind === "unknown" || rightKind === "unknown" ? "invalid" : "mismatched"
+	});
+}
+function isAllowed(leftKind, rightKind, options) {
+	if (leftKind === rightKind && [
+		"bigint",
+		"number",
+		"string"
+	].includes(leftKind)) return true;
+	if (options.allowNumberAndString && (leftKind === "string" && rightKind === "number" || leftKind === "number" && rightKind === "string")) return true;
+	if (leftKind === "string" && isStringCompanion(rightKind, options)) return true;
+	if (rightKind === "string" && isStringCompanion(leftKind, options)) return true;
+	return false;
+}
+function isStringCompanion(kind, options) {
+	return kind === "any" && options.allowAny || kind === "boolean" && options.allowBoolean || kind === "nullish" && options.allowNullish || kind === "regexp" && options.allowRegExp;
+}
+function resolveOptions(options) {
+	return {
+		...defaults,
+		...options[0]
+	};
+}
+//#endregion
+export { restrictPlusOperandsRule };
+
+//# sourceMappingURL=restrict_plus_operands.js.map

package/dist/rules/restrict_plus_operands.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"restrict_plus_operands.js","names":[],"sources":["../../ts/rules/restrict_plus_operands.ts"],"sourcesContent":["import { createNativeRule } from \"./rule_creator\";\nimport { classifyTypeText, typeTextAtNode } from \"./type_utils\";\n\ntype Options = {\n  allowAny?: boolean;\n  allowBoolean?: boolean;\n  allowNullish?: boolean;\n  allowNumberAndString?: boolean;\n  allowRegExp?: boolean;\n  skipCompoundAssignments?: boolean;\n};\n\nconst defaults: Required<Options> = {\n  allowAny: true,\n  allowBoolean: true,\n  allowNullish: true,\n  allowNumberAndString: true,\n  allowRegExp: false,\n  skipCompoundAssignments: false,\n};\n\nexport const restrictPlusOperandsRule = createNativeRule(\n  \"restrict-plus-operands\",\n  {\n    docs: {\n      description: \"Require plus operands to be explicitly compatible.\",\n    },\n    messages: {\n      invalid: \"Operands of + must be compatible primitive values.\",\n      mismatched: \"Operands of + operations must be of the same type.\",\n    },\n    schema: { type: \"array\" },\n  },\n  (context) => ({\n    AssignmentExpression(node: any) {\n      const options = resolveOptions(context.options);\n      if (options.skipCompoundAssignments || node.operator !== \"+=\") {\n        return;\n      }\n      reportIfInvalid(context, node, node.left, node.right, options);\n    },\n    BinaryExpression(node: any) {\n      if (node.operator !== \"+\") {\n        return;\n      }\n      reportIfInvalid(context, node, node.left, node.right, resolveOptions(context.options));\n    },\n  }),\n);\n\nfunction reportIfInvalid(\n  context: any,\n  node: any,\n  left: any,\n  right: any,\n  options: Required<Options>,\n) {\n  const leftKind = classifyTypeText(typeTextAtNode(context, left));\n  const rightKind = classifyTypeText(typeTextAtNode(context, right));\n  if (isAllowed(leftKind, rightKind, options)) {\n    return;\n  }\n  context.report({\n    node,\n    messageId:\n      leftKind === \"other\" ||\n      rightKind === \"other\" ||\n      leftKind === \"unknown\" ||\n      rightKind === \"unknown\"\n        ? \"invalid\"\n        : \"mismatched\",\n  });\n}\n\nfunction isAllowed(\n  leftKind: ReturnType<typeof classifyTypeText>,\n  rightKind: ReturnType<typeof classifyTypeText>,\n  options: Required<Options>,\n): boolean {\n  if (leftKind === rightKind && [\"bigint\", \"number\", \"string\"].includes(leftKind)) {\n    return true;\n  }\n  if (\n    options.allowNumberAndString &&\n    ((leftKind === \"string\" && rightKind === \"number\") ||\n      (leftKind === \"number\" && rightKind === \"string\"))\n  ) {\n    return true;\n  }\n  if (leftKind === \"string\" && isStringCompanion(rightKind, options)) {\n    return true;\n  }\n  if (rightKind === \"string\" && isStringCompanion(leftKind, options)) {\n    return true;\n  }\n  return false;\n}\n\nfunction isStringCompanion(\n  kind: ReturnType<typeof classifyTypeText>,\n  options: Required<Options>,\n): boolean {\n  return (\n    (kind === \"any\" && options.allowAny) ||\n    (kind === \"boolean\" && options.allowBoolean) ||\n    (kind === \"nullish\" && options.allowNullish) ||\n    (kind === \"regexp\" && options.allowRegExp)\n  );\n}\n\nfunction resolveOptions(options: readonly unknown[]): Required<Options> {\n  return { ...defaults, ...(options[0] as Options | undefined) };\n}\n"],"mappings":";;;AAYA,MAAM,WAA8B;CAClC,UAAU;CACV,cAAc;CACd,cAAc;CACd,sBAAsB;CACtB,aAAa;CACb,yBAAyB;CAC1B;AAED,MAAa,2BAA2B,iBACtC,0BACA;CACE,MAAM,EACJ,aAAa,sDACd;CACD,UAAU;EACR,SAAS;EACT,YAAY;EACb;CACD,QAAQ,EAAE,MAAM,SAAS;CAC1B,GACA,aAAa;CACZ,qBAAqB,MAAW;EAC9B,MAAM,UAAU,eAAe,QAAQ,QAAQ;AAC/C,MAAI,QAAQ,2BAA2B,KAAK,aAAa,KACvD;AAEF,kBAAgB,SAAS,MAAM,KAAK,MAAM,KAAK,OAAO,QAAQ;;CAEhE,iBAAiB,MAAW;AAC1B,MAAI,KAAK,aAAa,IACpB;AAEF,kBAAgB,SAAS,MAAM,KAAK,MAAM,KAAK,OAAO,eAAe,QAAQ,QAAQ,CAAC;;CAEzF,EACF;AAED,SAAS,gBACP,SACA,MACA,MACA,OACA,SACA;CACA,MAAM,WAAW,iBAAiB,eAAe,SAAS,KAAK,CAAC;CAChE,MAAM,YAAY,iBAAiB,eAAe,SAAS,MAAM,CAAC;AAClE,KAAI,UAAU,UAAU,WAAW,QAAQ,CACzC;AAEF,SAAQ,OAAO;EACb;EACA,WACE,aAAa,WACb,cAAc,WACd,aAAa,aACb,cAAc,YACV,YACA;EACP,CAAC;;AAGJ,SAAS,UACP,UACA,WACA,SACS;AACT,KAAI,aAAa,aAAa;EAAC;EAAU;EAAU;EAAS,CAAC,SAAS,SAAS,CAC7E,QAAO;AAET,KACE,QAAQ,yBACN,aAAa,YAAY,cAAc,YACtC,aAAa,YAAY,cAAc,UAE1C,QAAO;AAET,KAAI,aAAa,YAAY,kBAAkB,WAAW,QAAQ,CAChE,QAAO;AAET,KAAI,cAAc,YAAY,kBAAkB,UAAU,QAAQ,CAChE,QAAO;AAET,QAAO;;AAGT,SAAS,kBACP,MACA,SACS;AACT,QACG,SAAS,SAAS,QAAQ,YAC1B,SAAS,aAAa,QAAQ,gBAC9B,SAAS,aAAa,QAAQ,gBAC9B,SAAS,YAAY,QAAQ;;AAIlC,SAAS,eAAe,SAAgD;AACtE,QAAO;EAAE,GAAG;EAAU,GAAI,QAAQ;EAA4B"}

package/dist/rules/rule_creator.d.ts

@@ -0,0 +1,16 @@
+//#region src/bindings/nodejs/typescript_oxlint/ts/rules/rule_creator.d.ts
+declare function createNativeRule(name: string, meta: Record<string, unknown>, create: (context: any) => Record<string, (node: any) => void>): {
+  defaultOptions: never[];
+  meta: {
+    docs: {
+      requiresTypeChecking: boolean;
+      url: string;
+    };
+    type: "problem";
+    schema: never[];
+  };
+  create: (context: any) => Record<string, (node: any) => void>;
+};
+//#endregion
+export { createNativeRule };
+//# sourceMappingURL=rule_creator.d.ts.map

package/dist/rules/rule_creator.js

@@ -0,0 +1,22 @@
+import { defineRule } from "../plugin.js";
+//#region src/bindings/nodejs/typescript_oxlint/ts/rules/rule_creator.ts
+function createNativeRule(name, meta, create) {
+	return defineRule({
+		defaultOptions: [],
+		meta: {
+			type: "problem",
+			schema: [],
+			...meta,
+			docs: {
+				requiresTypeChecking: true,
+				url: `https://github.com/ubugeeei/corsa-bind/tree/main/src/bindings/nodejs/typescript_oxlint/ts/rules/${name.replaceAll("-", "_")}.ts`,
+				...meta.docs
+			}
+		},
+		create
+	});
+}
+//#endregion
+export { createNativeRule };
+
+//# sourceMappingURL=rule_creator.js.map

package/dist/rules/rule_creator.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"rule_creator.js","names":[],"sources":["../../ts/rules/rule_creator.ts"],"sourcesContent":["import { defineRule } from \"../plugin\";\n\nexport function createNativeRule(\n  name: string,\n  meta: Record<string, unknown>,\n  create: (context: any) => Record<string, (node: any) => void>,\n) {\n  return defineRule({\n    defaultOptions: [],\n    meta: {\n      type: \"problem\",\n      schema: [],\n      ...meta,\n      docs: {\n        requiresTypeChecking: true,\n        url: `https://github.com/ubugeeei/corsa-bind/tree/main/src/bindings/nodejs/typescript_oxlint/ts/rules/${name.replaceAll(\"-\", \"_\")}.ts`,\n        ...(meta.docs as object | undefined),\n      },\n    },\n    create,\n  });\n}\n"],"mappings":";;AAEA,SAAgB,iBACd,MACA,MACA,QACA;AACA,QAAO,WAAW;EAChB,gBAAgB,EAAE;EAClB,MAAM;GACJ,MAAM;GACN,QAAQ,EAAE;GACV,GAAG;GACH,MAAM;IACJ,sBAAsB;IACtB,KAAK,mGAAmG,KAAK,WAAW,KAAK,IAAI,CAAC;IAClI,GAAI,KAAK;IACV;GACF;EACD;EACD,CAAC"}

package/dist/rules/type_utils.d.ts

@@ -0,0 +1,56 @@
+import { ContextWithParserOptions, TsgoType, TsgoTypeCheckerShape } from "../types.js";
+import { Node } from "@oxlint/plugins";
+
+//#region src/bindings/nodejs/typescript_oxlint/ts/rules/type_utils.d.ts
+declare function checkerFor(context: ContextWithParserOptions): TsgoTypeCheckerShape;
+declare function typeAtNode(context: ContextWithParserOptions, node: Node | {
+  readonly range: readonly [number, number];
+}): TsgoType | undefined;
+declare function baseTypeAtNode(context: ContextWithParserOptions, node: Node | {
+  readonly range: readonly [number, number];
+}): TsgoType | undefined;
+declare function symbolTypeAtNode(context: ContextWithParserOptions, node: Node | {
+  readonly range: readonly [number, number];
+}): TsgoType | undefined;
+declare function typeTextAtNode(context: ContextWithParserOptions, node: Node | {
+  readonly range: readonly [number, number];
+}): string | undefined;
+declare function symbolTypeTextAtNode(context: ContextWithParserOptions, node: Node | {
+  readonly range: readonly [number, number];
+}): string | undefined;
+declare function propertyNamesOfNode(context: ContextWithParserOptions, node: Node | {
+  readonly range: readonly [number, number];
+}): readonly string[];
+declare function isPromiseLikeNode(context: ContextWithParserOptions, node: Node | {
+  readonly range: readonly [number, number];
+}): boolean;
+declare function isArrayLikeNode(context: ContextWithParserOptions, node: Node | {
+  readonly range: readonly [number, number];
+}): boolean;
+declare function isStringLikeNode(context: ContextWithParserOptions, node: Node | {
+  readonly range: readonly [number, number];
+}): boolean;
+declare function isErrorLikeNode(context: ContextWithParserOptions, node: Node | {
+  readonly range: readonly [number, number];
+}): boolean;
+declare function isNumberLikeNode(context: ContextWithParserOptions, node: Node | {
+  readonly range: readonly [number, number];
+}): boolean;
+declare function isBigIntLikeNode(context: ContextWithParserOptions, node: Node | {
+  readonly range: readonly [number, number];
+}): boolean;
+declare function isAnyLikeNode(context: ContextWithParserOptions, node: Node | {
+  readonly range: readonly [number, number];
+}): boolean;
+declare function isUnknownLikeNode(context: ContextWithParserOptions, node: Node | {
+  readonly range: readonly [number, number];
+}): boolean;
+declare function typeTextsAtNode(context: ContextWithParserOptions, node: Node | {
+  readonly range: readonly [number, number];
+}): readonly string[];
+declare function classifyTypeText(text: string | undefined): "any" | "bigint" | "boolean" | "nullish" | "number" | "regexp" | "string" | "unknown" | "other";
+declare function splitTopLevelTypeText(text: string, delimiter: "|" | "&" | ","): readonly string[];
+declare function splitTypeText(text: string): readonly string[];
+//#endregion
+export { baseTypeAtNode, checkerFor, classifyTypeText, isAnyLikeNode, isArrayLikeNode, isBigIntLikeNode, isErrorLikeNode, isNumberLikeNode, isPromiseLikeNode, isStringLikeNode, isUnknownLikeNode, propertyNamesOfNode, splitTopLevelTypeText, splitTypeText, symbolTypeAtNode, symbolTypeTextAtNode, typeAtNode, typeTextAtNode, typeTextsAtNode };
+//# sourceMappingURL=type_utils.d.ts.map

package/dist/rules/type_utils.js

@@ -0,0 +1,102 @@
+import { ESLintUtils } from "../eslint_utils.js";
+import { classifyTypeText as classifyTypeText$1, isAnyLikeTypeTexts, isArrayLikeTypeTexts, isBigIntLikeTypeTexts, isErrorLikeTypeTexts, isNumberLikeTypeTexts, isPromiseLikeTypeTexts, isStringLikeTypeTexts, isUnknownLikeTypeTexts, splitTopLevelTypeText as splitTopLevelTypeText$1, splitTypeText as splitTypeText$1 } from "../utils.js";
+import { isIdentifierNamed, memberPropertyName, stripChainExpression } from "./ast.js";
+//#region src/bindings/nodejs/typescript_oxlint/ts/rules/type_utils.ts
+function checkerFor(context) {
+	return ESLintUtils.getParserServices(context).program.getTypeChecker();
+}
+function typeAtNode(context, node) {
+	return checkerFor(context).getTypeAtLocation(node);
+}
+function baseTypeAtNode(context, node) {
+	const type = typeAtNode(context, node);
+	if (!type) return;
+	return checkerFor(context).getBaseTypeOfLiteralType(type) ?? type;
+}
+function symbolTypeAtNode(context, node) {
+	const checker = checkerFor(context);
+	const symbol = checker.getSymbolAtLocation(node);
+	if (!symbol) return;
+	return checker.getTypeOfSymbol(symbol) ?? checker.getDeclaredTypeOfSymbol(symbol);
+}
+function typeTextAtNode(context, node) {
+	const type = baseTypeAtNode(context, node);
+	return type ? checkerFor(context).typeToString(type) : void 0;
+}
+function symbolTypeTextAtNode(context, node) {
+	const type = symbolTypeAtNode(context, node);
+	if (!type) return;
+	const checker = checkerFor(context);
+	return checker.typeToString(checker.getBaseTypeOfLiteralType(type) ?? type);
+}
+function propertyNamesOfNode(context, node) {
+	const checker = checkerFor(context);
+	const names = /* @__PURE__ */ new Set();
+	for (const type of [baseTypeAtNode(context, node), symbolTypeAtNode(context, node)]) {
+		if (!type) continue;
+		for (const property of checker.getPropertiesOfType(type)) names.add(property.name);
+	}
+	return [...names];
+}
+function isPromiseLikeNode(context, node) {
+	const current = stripChainExpression(node);
+	if (current?.type === "NewExpression" && isIdentifierNamed(current.callee, "Promise")) return true;
+	if (current?.type === "CallExpression" && memberPropertyName(current.callee) === "resolve" && isIdentifierNamed(current.callee.object, "Promise")) return true;
+	return isPromiseLikeTypeTexts([typeTextAtNode(context, node), symbolTypeTextAtNode(context, node)].filter((text) => Boolean(text)), propertyNamesOfNode(context, node));
+}
+function isArrayLikeNode(context, node) {
+	if (stripChainExpression(node)?.type === "ArrayExpression") return true;
+	return isArrayLikeTypeTexts(typeTextsAtNode(context, node));
+}
+function isStringLikeNode(context, node) {
+	return isStringLikeTypeTexts(typeTextsAtNode(context, node));
+}
+function isErrorLikeNode(context, node) {
+	const current = stripChainExpression(node);
+	if (current?.type === "NewExpression") {
+		const callee = stripChainExpression(current.callee);
+		if ((callee?.type === "Identifier" ? callee.name : memberPropertyName(callee))?.endsWith("Error")) return true;
+	}
+	return isErrorLikeTypeTexts(typeTextsAtNode(context, node), propertyNamesOfNode(context, node));
+}
+function isNumberLikeNode(context, node) {
+	return isNumberLikeTypeTexts(typeTextsAtNode(context, node));
+}
+function isBigIntLikeNode(context, node) {
+	return isBigIntLikeTypeTexts(typeTextsAtNode(context, node));
+}
+function isAnyLikeNode(context, node) {
+	const current = stripChainExpression(node);
+	if (current?.type === "TSAsExpression" && current.typeAnnotation?.type === "TSAnyKeyword") return true;
+	return isAnyLikeTypeTexts(typeTextsAtNode(context, node));
+}
+function isUnknownLikeNode(context, node) {
+	const current = stripChainExpression(node);
+	if (current?.type === "TSAsExpression" && current.typeAnnotation?.type === "TSUnknownKeyword") return true;
+	return isUnknownLikeTypeTexts(typeTextsAtNode(context, node));
+}
+function typeTextsAtNode(context, node) {
+	const values = /* @__PURE__ */ new Set();
+	const checker = checkerFor(context);
+	collectTexts(baseTypeAtNode(context, node));
+	collectTexts(symbolTypeAtNode(context, node));
+	return [...values];
+	function collectTexts(type) {
+		if (!type) return;
+		const texts = Array.isArray(type.texts) ? type.texts : [];
+		for (const text of [...texts, checker.typeToString(type)]) if (text) values.add(text);
+	}
+}
+function classifyTypeText(text) {
+	return classifyTypeText$1(text);
+}
+function splitTopLevelTypeText(text, delimiter) {
+	return splitTopLevelTypeText$1(text, delimiter);
+}
+function splitTypeText(text) {
+	return splitTypeText$1(text);
+}
+//#endregion
+export { baseTypeAtNode, checkerFor, classifyTypeText, isAnyLikeNode, isArrayLikeNode, isBigIntLikeNode, isErrorLikeNode, isNumberLikeNode, isPromiseLikeNode, isStringLikeNode, isUnknownLikeNode, propertyNamesOfNode, splitTopLevelTypeText, splitTypeText, symbolTypeAtNode, symbolTypeTextAtNode, typeAtNode, typeTextAtNode, typeTextsAtNode };
+
+//# sourceMappingURL=type_utils.js.map

package/dist/rules/type_utils.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"type_utils.js","names":["classifyTypeTextFromRust","splitTopLevelTypeTextFromRust","splitTypeTextFromRust"],"sources":["../../ts/rules/type_utils.ts"],"sourcesContent":["import type { Node } from \"@oxlint/plugins\";\n\nimport { ESLintUtils } from \"../eslint_utils\";\nimport {\n  classifyTypeText as classifyTypeTextFromRust,\n  isAnyLikeTypeTexts,\n  isArrayLikeTypeTexts,\n  isBigIntLikeTypeTexts,\n  isErrorLikeTypeTexts,\n  isNumberLikeTypeTexts,\n  isPromiseLikeTypeTexts,\n  isStringLikeTypeTexts,\n  isUnknownLikeTypeTexts,\n  splitTopLevelTypeText as splitTopLevelTypeTextFromRust,\n  splitTypeText as splitTypeTextFromRust,\n} from \"../utils\";\nimport { isIdentifierNamed, memberPropertyName, stripChainExpression } from \"./ast\";\nimport type { ContextWithParserOptions, TsgoType, TsgoTypeCheckerShape } from \"../types\";\n\nexport function checkerFor(context: ContextWithParserOptions): TsgoTypeCheckerShape {\n  return ESLintUtils.getParserServices(context).program.getTypeChecker();\n}\n\nexport function typeAtNode(\n  context: ContextWithParserOptions,\n  node: Node | { readonly range: readonly [number, number] },\n): TsgoType | undefined {\n  return checkerFor(context).getTypeAtLocation(node as Node);\n}\n\nexport function baseTypeAtNode(\n  context: ContextWithParserOptions,\n  node: Node | { readonly range: readonly [number, number] },\n): TsgoType | undefined {\n  const type = typeAtNode(context, node);\n  if (!type) {\n    return undefined;\n  }\n  return checkerFor(context).getBaseTypeOfLiteralType(type) ?? type;\n}\n\nexport function symbolTypeAtNode(\n  context: ContextWithParserOptions,\n  node: Node | { readonly range: readonly [number, number] },\n): TsgoType | undefined {\n  const checker = checkerFor(context);\n  const symbol = checker.getSymbolAtLocation(node as Node);\n  if (!symbol) {\n    return undefined;\n  }\n  return checker.getTypeOfSymbol(symbol) ?? checker.getDeclaredTypeOfSymbol(symbol);\n}\n\nexport function typeTextAtNode(\n  context: ContextWithParserOptions,\n  node: Node | { readonly range: readonly [number, number] },\n): string | undefined {\n  const type = baseTypeAtNode(context, node);\n  return type ? checkerFor(context).typeToString(type) : undefined;\n}\n\nexport function symbolTypeTextAtNode(\n  context: ContextWithParserOptions,\n  node: Node | { readonly range: readonly [number, number] },\n): string | undefined {\n  const type = symbolTypeAtNode(context, node);\n  if (!type) {\n    return undefined;\n  }\n  const checker = checkerFor(context);\n  return checker.typeToString(checker.getBaseTypeOfLiteralType(type) ?? type);\n}\n\nexport function propertyNamesOfNode(\n  context: ContextWithParserOptions,\n  node: Node | { readonly range: readonly [number, number] },\n): readonly string[] {\n  const checker = checkerFor(context);\n  const names = new Set<string>();\n  for (const type of [baseTypeAtNode(context, node), symbolTypeAtNode(context, node)]) {\n    if (!type) {\n      continue;\n    }\n    for (const property of checker.getPropertiesOfType(type)) {\n      names.add(property.name);\n    }\n  }\n  return [...names];\n}\n\nexport function isPromiseLikeNode(\n  context: ContextWithParserOptions,\n  node: Node | { readonly range: readonly [number, number] },\n): boolean {\n  const current = stripChainExpression(node as any) as any;\n  if (current?.type === \"NewExpression\" && isIdentifierNamed(current.callee, \"Promise\")) {\n    return true;\n  }\n  if (\n    current?.type === \"CallExpression\" &&\n    memberPropertyName(current.callee) === \"resolve\" &&\n    isIdentifierNamed((current.callee as any).object, \"Promise\")\n  ) {\n    return true;\n  }\n  return isPromiseLikeTypeTexts(\n    [typeTextAtNode(context, node), symbolTypeTextAtNode(context, node)].filter(\n      (text): text is string => Boolean(text),\n    ),\n    propertyNamesOfNode(context, node),\n  );\n}\n\nexport function isArrayLikeNode(\n  context: ContextWithParserOptions,\n  node: Node | { readonly range: readonly [number, number] },\n): boolean {\n  const current = stripChainExpression(node as any) as any;\n  if (current?.type === \"ArrayExpression\") {\n    return true;\n  }\n  return isArrayLikeTypeTexts(typeTextsAtNode(context, node));\n}\n\nexport function isStringLikeNode(\n  context: ContextWithParserOptions,\n  node: Node | { readonly range: readonly [number, number] },\n): boolean {\n  return isStringLikeTypeTexts(typeTextsAtNode(context, node));\n}\n\nexport function isErrorLikeNode(\n  context: ContextWithParserOptions,\n  node: Node | { readonly range: readonly [number, number] },\n): boolean {\n  const current = stripChainExpression(node as any) as any;\n  if (current?.type === \"NewExpression\") {\n    const callee = stripChainExpression(current.callee);\n    const identifier = callee?.type === \"Identifier\" ? callee.name : memberPropertyName(callee);\n    if (identifier?.endsWith(\"Error\")) {\n      return true;\n    }\n  }\n  return isErrorLikeTypeTexts(typeTextsAtNode(context, node), propertyNamesOfNode(context, node));\n}\n\nexport function isNumberLikeNode(\n  context: ContextWithParserOptions,\n  node: Node | { readonly range: readonly [number, number] },\n): boolean {\n  return isNumberLikeTypeTexts(typeTextsAtNode(context, node));\n}\n\nexport function isBigIntLikeNode(\n  context: ContextWithParserOptions,\n  node: Node | { readonly range: readonly [number, number] },\n): boolean {\n  return isBigIntLikeTypeTexts(typeTextsAtNode(context, node));\n}\n\nexport function isAnyLikeNode(\n  context: ContextWithParserOptions,\n  node: Node | { readonly range: readonly [number, number] },\n): boolean {\n  const current = stripChainExpression(node as any) as any;\n  if (current?.type === \"TSAsExpression\" && current.typeAnnotation?.type === \"TSAnyKeyword\") {\n    return true;\n  }\n  return isAnyLikeTypeTexts(typeTextsAtNode(context, node));\n}\n\nexport function isUnknownLikeNode(\n  context: ContextWithParserOptions,\n  node: Node | { readonly range: readonly [number, number] },\n): boolean {\n  const current = stripChainExpression(node as any) as any;\n  if (current?.type === \"TSAsExpression\" && current.typeAnnotation?.type === \"TSUnknownKeyword\") {\n    return true;\n  }\n  return isUnknownLikeTypeTexts(typeTextsAtNode(context, node));\n}\n\nexport function typeTextsAtNode(\n  context: ContextWithParserOptions,\n  node: Node | { readonly range: readonly [number, number] },\n): readonly string[] {\n  const values = new Set<string>();\n  const checker = checkerFor(context);\n  collectTexts(baseTypeAtNode(context, node));\n  collectTexts(symbolTypeAtNode(context, node));\n  return [...values];\n\n  function collectTexts(type: TsgoType | undefined): void {\n    if (!type) {\n      return;\n    }\n    const texts = Array.isArray(type.texts) ? type.texts : [];\n    for (const text of [...texts, checker.typeToString(type)]) {\n      if (text) {\n        values.add(text);\n      }\n    }\n  }\n}\n\nexport function classifyTypeText(\n  text: string | undefined,\n): \"any\" | \"bigint\" | \"boolean\" | \"nullish\" | \"number\" | \"regexp\" | \"string\" | \"unknown\" | \"other\" {\n  return classifyTypeTextFromRust(text);\n}\n\nexport function splitTopLevelTypeText(text: string, delimiter: \"|\" | \"&\" | \",\"): readonly string[] {\n  return splitTopLevelTypeTextFromRust(text, delimiter);\n}\n\nexport function splitTypeText(text: string): readonly string[] {\n  return splitTypeTextFromRust(text);\n}\n"],"mappings":";;;;AAmBA,SAAgB,WAAW,SAAyD;AAClF,QAAO,YAAY,kBAAkB,QAAQ,CAAC,QAAQ,gBAAgB;;AAGxE,SAAgB,WACd,SACA,MACsB;AACtB,QAAO,WAAW,QAAQ,CAAC,kBAAkB,KAAa;;AAG5D,SAAgB,eACd,SACA,MACsB;CACtB,MAAM,OAAO,WAAW,SAAS,KAAK;AACtC,KAAI,CAAC,KACH;AAEF,QAAO,WAAW,QAAQ,CAAC,yBAAyB,KAAK,IAAI;;AAG/D,SAAgB,iBACd,SACA,MACsB;CACtB,MAAM,UAAU,WAAW,QAAQ;CACnC,MAAM,SAAS,QAAQ,oBAAoB,KAAa;AACxD,KAAI,CAAC,OACH;AAEF,QAAO,QAAQ,gBAAgB,OAAO,IAAI,QAAQ,wBAAwB,OAAO;;AAGnF,SAAgB,eACd,SACA,MACoB;CACpB,MAAM,OAAO,eAAe,SAAS,KAAK;AAC1C,QAAO,OAAO,WAAW,QAAQ,CAAC,aAAa,KAAK,GAAG,KAAA;;AAGzD,SAAgB,qBACd,SACA,MACoB;CACpB,MAAM,OAAO,iBAAiB,SAAS,KAAK;AAC5C,KAAI,CAAC,KACH;CAEF,MAAM,UAAU,WAAW,QAAQ;AACnC,QAAO,QAAQ,aAAa,QAAQ,yBAAyB,KAAK,IAAI,KAAK;;AAG7E,SAAgB,oBACd,SACA,MACmB;CACnB,MAAM,UAAU,WAAW,QAAQ;CACnC,MAAM,wBAAQ,IAAI,KAAa;AAC/B,MAAK,MAAM,QAAQ,CAAC,eAAe,SAAS,KAAK,EAAE,iBAAiB,SAAS,KAAK,CAAC,EAAE;AACnF,MAAI,CAAC,KACH;AAEF,OAAK,MAAM,YAAY,QAAQ,oBAAoB,KAAK,CACtD,OAAM,IAAI,SAAS,KAAK;;AAG5B,QAAO,CAAC,GAAG,MAAM;;AAGnB,SAAgB,kBACd,SACA,MACS;CACT,MAAM,UAAU,qBAAqB,KAAY;AACjD,KAAI,SAAS,SAAS,mBAAmB,kBAAkB,QAAQ,QAAQ,UAAU,CACnF,QAAO;AAET,KACE,SAAS,SAAS,oBAClB,mBAAmB,QAAQ,OAAO,KAAK,aACvC,kBAAmB,QAAQ,OAAe,QAAQ,UAAU,CAE5D,QAAO;AAET,QAAO,uBACL,CAAC,eAAe,SAAS,KAAK,EAAE,qBAAqB,SAAS,KAAK,CAAC,CAAC,QAClE,SAAyB,QAAQ,KAAK,CACxC,EACD,oBAAoB,SAAS,KAAK,CACnC;;AAGH,SAAgB,gBACd,SACA,MACS;AAET,KADgB,qBAAqB,KAAY,EACpC,SAAS,kBACpB,QAAO;AAET,QAAO,qBAAqB,gBAAgB,SAAS,KAAK,CAAC;;AAG7D,SAAgB,iBACd,SACA,MACS;AACT,QAAO,sBAAsB,gBAAgB,SAAS,KAAK,CAAC;;AAG9D,SAAgB,gBACd,SACA,MACS;CACT,MAAM,UAAU,qBAAqB,KAAY;AACjD,KAAI,SAAS,SAAS,iBAAiB;EACrC,MAAM,SAAS,qBAAqB,QAAQ,OAAO;AAEnD,OADmB,QAAQ,SAAS,eAAe,OAAO,OAAO,mBAAmB,OAAO,GAC3E,SAAS,QAAQ,CAC/B,QAAO;;AAGX,QAAO,qBAAqB,gBAAgB,SAAS,KAAK,EAAE,oBAAoB,SAAS,KAAK,CAAC;;AAGjG,SAAgB,iBACd,SACA,MACS;AACT,QAAO,sBAAsB,gBAAgB,SAAS,KAAK,CAAC;;AAG9D,SAAgB,iBACd,SACA,MACS;AACT,QAAO,sBAAsB,gBAAgB,SAAS,KAAK,CAAC;;AAG9D,SAAgB,cACd,SACA,MACS;CACT,MAAM,UAAU,qBAAqB,KAAY;AACjD,KAAI,SAAS,SAAS,oBAAoB,QAAQ,gBAAgB,SAAS,eACzE,QAAO;AAET,QAAO,mBAAmB,gBAAgB,SAAS,KAAK,CAAC;;AAG3D,SAAgB,kBACd,SACA,MACS;CACT,MAAM,UAAU,qBAAqB,KAAY;AACjD,KAAI,SAAS,SAAS,oBAAoB,QAAQ,gBAAgB,SAAS,mBACzE,QAAO;AAET,QAAO,uBAAuB,gBAAgB,SAAS,KAAK,CAAC;;AAG/D,SAAgB,gBACd,SACA,MACmB;CACnB,MAAM,yBAAS,IAAI,KAAa;CAChC,MAAM,UAAU,WAAW,QAAQ;AACnC,cAAa,eAAe,SAAS,KAAK,CAAC;AAC3C,cAAa,iBAAiB,SAAS,KAAK,CAAC;AAC7C,QAAO,CAAC,GAAG,OAAO;CAElB,SAAS,aAAa,MAAkC;AACtD,MAAI,CAAC,KACH;EAEF,MAAM,QAAQ,MAAM,QAAQ,KAAK,MAAM,GAAG,KAAK,QAAQ,EAAE;AACzD,OAAK,MAAM,QAAQ,CAAC,GAAG,OAAO,QAAQ,aAAa,KAAK,CAAC,CACvD,KAAI,KACF,QAAO,IAAI,KAAK;;;AAMxB,SAAgB,iBACd,MACiG;AACjG,QAAOA,mBAAyB,KAAK;;AAGvC,SAAgB,sBAAsB,MAAc,WAA+C;AACjG,QAAOC,wBAA8B,MAAM,UAAU;;AAGvD,SAAgB,cAAc,MAAiC;AAC7D,QAAOC,gBAAsB,KAAK"}