corsa-oxlint 0.1.0

package/dist/rule_tester.d.ts

@@ -0,0 +1,37 @@
+import * as oxlint_plugins_dev0 from "oxlint/plugins-dev";
+
+//#region src/bindings/nodejs/typescript_oxlint/ts/rule_tester.d.ts
+type TesterConfig = oxlint_plugins_dev0.RuleTester.Config;
+type TestCase = oxlint_plugins_dev0.RuleTester.ValidTestCase & Partial<oxlint_plugins_dev0.RuleTester.InvalidTestCase>;
+type TestCases = oxlint_plugins_dev0.RuleTester.TestCases;
+declare class RuleTester {
+  #private;
+  /**
+   * A thin Oxlint `RuleTester` wrapper that injects
+   * `settings.typescriptOxlint`
+   * settings, temporary fixtures, and a default project service.
+   *
+   * @example
+   * ```ts
+   * const tester = new RuleTester();
+   * tester.run("demo", rule, {
+   *   valid: [{ code: "const answer = 42;" }],
+   *   invalid: [],
+   * });
+   * ```
+   */
+  static get describe(): (text: string, fn: () => void) => void;
+  static set describe(value: (text: string, fn: () => void) => void);
+  static get it(): ((text: string, fn: () => void) => void) & {
+    only?: ((text: string, fn: () => void) => void) & /*elided*/any;
+  };
+  static set it(value: ((text: string, fn: () => void) => void) & {
+    only?: ((text: string, fn: () => void) => void) & /*elided*/any;
+  });
+  static only(item: string | TestCase): TestCase;
+  constructor(config?: TesterConfig);
+  run(ruleName: string, rule: Record<string, unknown>, tests: TestCases): void;
+}
+//#endregion
+export { RuleTester };
+//# sourceMappingURL=rule_tester.d.ts.map

package/dist/rule_tester.js

@@ -0,0 +1,120 @@
+import { mergeTypeAwareParserOptions } from "./context.js";
+import { decorateRule } from "./plugin.js";
+import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import { dirname, join, resolve } from "node:path";
+import { tmpdir } from "node:os";
+import { RuleTester as RuleTester$1 } from "oxlint/plugins-dev";
+//#region src/bindings/nodejs/typescript_oxlint/ts/rule_tester.ts
+const cleanupDirs = /* @__PURE__ */ new Set();
+let cleanupInstalled = false;
+var RuleTester = class {
+	/**
+	* A thin Oxlint `RuleTester` wrapper that injects
+	* `settings.typescriptOxlint`
+	* settings, temporary fixtures, and a default project service.
+	*
+	* @example
+	* ```ts
+	* const tester = new RuleTester();
+	* tester.run("demo", rule, {
+	*   valid: [{ code: "const answer = 42;" }],
+	*   invalid: [],
+	* });
+	* ```
+	*/
+	static get describe() {
+		return RuleTester$1.describe;
+	}
+	static set describe(value) {
+		RuleTester$1.describe = value;
+	}
+	static get it() {
+		return RuleTester$1.it;
+	}
+	static set it(value) {
+		RuleTester$1.it = value;
+	}
+	static only(item) {
+		return RuleTester$1.only(item);
+	}
+	#inner;
+	#config;
+	constructor(config) {
+		this.#config = config;
+		this.#inner = new RuleTester$1(config);
+	}
+	run(ruleName, rule, tests) {
+		const workspace = mkdtempSync(join(tmpdir(), "oxlint-plugin-typescript-go-"));
+		registerCleanup(workspace);
+		const transformed = {
+			valid: tests.valid.map((test) => prepareTestCase(workspace, test, this.#config)),
+			invalid: tests.invalid.map((test) => prepareTestCase(workspace, test, this.#config))
+		};
+		this.#inner.run(ruleName, decorateRule(rule), transformed);
+	}
+};
+function prepareTestCase(workspace, test, config) {
+	if (typeof test === "string") {
+		writeFixture(resolve(workspace, "fixture.ts"), test);
+		return test;
+	}
+	const filename = resolve(workspace, test.filename ?? "fixture.ts");
+	writeFixture(filename, test.code);
+	const testerConfig = config;
+	const baseSettings = testerConfig?.settings?.typescriptOxlint;
+	const caseSettings = test.settings?.typescriptOxlint;
+	const parserOptions = mergeTypeAwareParserOptions(mergeTypeAwareParserOptions(mergeTypeAwareParserOptions(mergeTypeAwareParserOptions(baseSettings, baseSettings?.parserOptions), mergeTypeAwareParserOptions(caseSettings, caseSettings?.parserOptions)), {
+		tsconfigRootDir: workspace,
+		projectService: { allowDefaultProject: [
+			"*.ts",
+			"*.tsx",
+			"*.js",
+			"*.jsx"
+		] }
+	}), mergeTypeAwareParserOptions(config?.languageOptions?.parserOptions, test.languageOptions?.parserOptions));
+	return {
+		...test,
+		filename,
+		settings: {
+			...testerConfig?.settings,
+			...test.settings,
+			typescriptOxlint: {
+				...testerConfig?.settings?.typescriptOxlint,
+				...test.settings?.typescriptOxlint,
+				parserOptions
+			}
+		},
+		languageOptions: {
+			...config?.languageOptions,
+			...test.languageOptions,
+			parserOptions: { ...parserOptions }
+		}
+	};
+}
+function writeFixture(filename, code) {
+	mkdirSync(dirname(filename), { recursive: true });
+	writeFileSync(filename, code);
+	writeFileSync(resolve(dirname(filename), "tsconfig.json"), JSON.stringify({
+		compilerOptions: {
+			module: "esnext",
+			target: "es2022",
+			strict: true
+		},
+		include: ["**/*"]
+	}, null, 2));
+}
+function registerCleanup(workspace) {
+	cleanupDirs.add(workspace);
+	if (cleanupInstalled) return;
+	cleanupInstalled = true;
+	process.on("exit", () => {
+		for (const dir of cleanupDirs) rmSync(dir, {
+			force: true,
+			recursive: true
+		});
+	});
+}
+//#endregion
+export { RuleTester };
+
+//# sourceMappingURL=rule_tester.js.map

package/dist/rule_tester.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"rule_tester.js","names":["OxlintRuleTester","#inner","#config"],"sources":["../ts/rule_tester.ts"],"sourcesContent":["import { mkdtempSync, mkdirSync, rmSync, writeFileSync } from \"node:fs\";\nimport { tmpdir } from \"node:os\";\nimport { dirname, join, resolve } from \"node:path\";\n\nimport { RuleTester as OxlintRuleTester } from \"oxlint/plugins-dev\";\n\nimport { mergeTypeAwareParserOptions } from \"./context\";\nimport { decorateRule } from \"./plugin\";\nimport type { TypeAwareParserOptions, TypescriptOxlintSettings } from \"./types\";\n\ntype TesterConfig = import(\"oxlint/plugins-dev\").RuleTester.Config;\ntype TestCase = import(\"oxlint/plugins-dev\").RuleTester.ValidTestCase &\n  Partial<import(\"oxlint/plugins-dev\").RuleTester.InvalidTestCase>;\ntype TestCases = import(\"oxlint/plugins-dev\").RuleTester.TestCases;\ntype ConfigWithSettings = TesterConfig & {\n  settings?: {\n    typescriptOxlint?: TypescriptOxlintSettings;\n    [key: string]: unknown;\n  };\n};\n\nconst cleanupDirs = new Set<string>();\nlet cleanupInstalled = false;\n\nexport class RuleTester {\n  /**\n   * A thin Oxlint `RuleTester` wrapper that injects\n   * `settings.typescriptOxlint`\n   * settings, temporary fixtures, and a default project service.\n   *\n   * @example\n   * ```ts\n   * const tester = new RuleTester();\n   * tester.run(\"demo\", rule, {\n   *   valid: [{ code: \"const answer = 42;\" }],\n   *   invalid: [],\n   * });\n   * ```\n   */\n  static get describe() {\n    return OxlintRuleTester.describe;\n  }\n\n  static set describe(value) {\n    OxlintRuleTester.describe = value;\n  }\n\n  static get it() {\n    return OxlintRuleTester.it;\n  }\n\n  static set it(value) {\n    OxlintRuleTester.it = value;\n  }\n\n  static only(item: string | TestCase): TestCase {\n    return OxlintRuleTester.only(item);\n  }\n\n  readonly #inner: OxlintRuleTester;\n  readonly #config?: TesterConfig;\n\n  constructor(config?: TesterConfig) {\n    this.#config = config;\n    this.#inner = new OxlintRuleTester(config);\n  }\n\n  run(ruleName: string, rule: Record<string, unknown>, tests: TestCases): void {\n    const workspace = mkdtempSync(join(tmpdir(), \"oxlint-plugin-typescript-go-\"));\n    registerCleanup(workspace);\n    const transformed = {\n      valid: tests.valid.map((test) => prepareTestCase(workspace, test, this.#config)),\n      invalid: tests.invalid.map((test) => prepareTestCase(workspace, test, this.#config)),\n    };\n    this.#inner.run(ruleName, decorateRule(rule as never) as never, transformed as TestCases);\n  }\n}\n\nfunction prepareTestCase(\n  workspace: string,\n  test: string | TestCase,\n  config: TesterConfig | undefined,\n): string | TestCase {\n  if (typeof test === \"string\") {\n    const filename = resolve(workspace, \"fixture.ts\");\n    writeFixture(filename, test);\n    return test;\n  }\n  const filename = resolve(workspace, test.filename ?? \"fixture.ts\");\n  writeFixture(filename, test.code);\n  const testerConfig = config as ConfigWithSettings | undefined;\n  const baseSettings = testerConfig?.settings?.typescriptOxlint;\n  const caseSettings = (\n    test.settings as {\n      typescriptOxlint?: TypescriptOxlintSettings;\n    }\n  )?.typescriptOxlint;\n  const parserOptions = mergeTypeAwareParserOptions(\n    mergeTypeAwareParserOptions(\n      mergeTypeAwareParserOptions(\n        mergeTypeAwareParserOptions(baseSettings, baseSettings?.parserOptions),\n        mergeTypeAwareParserOptions(caseSettings, caseSettings?.parserOptions),\n      ),\n      {\n        tsconfigRootDir: workspace,\n        projectService: {\n          allowDefaultProject: [\"*.ts\", \"*.tsx\", \"*.js\", \"*.jsx\"],\n        },\n      },\n    ),\n    mergeTypeAwareParserOptions(\n      config?.languageOptions?.parserOptions as TypeAwareParserOptions | undefined,\n      test.languageOptions?.parserOptions as TypeAwareParserOptions | undefined,\n    ),\n  );\n  return {\n    ...test,\n    filename,\n    settings: {\n      ...testerConfig?.settings,\n      ...test.settings,\n      typescriptOxlint: {\n        ...testerConfig?.settings?.typescriptOxlint,\n        ...(test.settings as { typescriptOxlint?: TypescriptOxlintSettings })?.typescriptOxlint,\n        parserOptions,\n      },\n    } as never,\n    languageOptions: {\n      ...config?.languageOptions,\n      ...test.languageOptions,\n      parserOptions: {\n        ...parserOptions,\n      } as never,\n    },\n  };\n}\n\nfunction writeFixture(filename: string, code: string): void {\n  mkdirSync(dirname(filename), { recursive: true });\n  writeFileSync(filename, code);\n  const configPath = resolve(dirname(filename), \"tsconfig.json\");\n  writeFileSync(\n    configPath,\n    JSON.stringify(\n      {\n        compilerOptions: {\n          module: \"esnext\",\n          target: \"es2022\",\n          strict: true,\n        },\n        include: [\"**/*\"],\n      },\n      null,\n      2,\n    ),\n  );\n}\n\nfunction registerCleanup(workspace: string): void {\n  cleanupDirs.add(workspace);\n  if (cleanupInstalled) {\n    return;\n  }\n  cleanupInstalled = true;\n  process.on(\"exit\", () => {\n    for (const dir of cleanupDirs) {\n      rmSync(dir, { force: true, recursive: true });\n    }\n  });\n}\n"],"mappings":";;;;;;;AAqBA,MAAM,8BAAc,IAAI,KAAa;AACrC,IAAI,mBAAmB;AAEvB,IAAa,aAAb,MAAwB;;;;;;;;;;;;;;;CAetB,WAAW,WAAW;AACpB,SAAOA,aAAiB;;CAG1B,WAAW,SAAS,OAAO;AACzB,eAAiB,WAAW;;CAG9B,WAAW,KAAK;AACd,SAAOA,aAAiB;;CAG1B,WAAW,GAAG,OAAO;AACnB,eAAiB,KAAK;;CAGxB,OAAO,KAAK,MAAmC;AAC7C,SAAOA,aAAiB,KAAK,KAAK;;CAGpC;CACA;CAEA,YAAY,QAAuB;AACjC,QAAA,SAAe;AACf,QAAA,QAAc,IAAIA,aAAiB,OAAO;;CAG5C,IAAI,UAAkB,MAA+B,OAAwB;EAC3E,MAAM,YAAY,YAAY,KAAK,QAAQ,EAAE,+BAA+B,CAAC;AAC7E,kBAAgB,UAAU;EAC1B,MAAM,cAAc;GAClB,OAAO,MAAM,MAAM,KAAK,SAAS,gBAAgB,WAAW,MAAM,MAAA,OAAa,CAAC;GAChF,SAAS,MAAM,QAAQ,KAAK,SAAS,gBAAgB,WAAW,MAAM,MAAA,OAAa,CAAC;GACrF;AACD,QAAA,MAAY,IAAI,UAAU,aAAa,KAAc,EAAW,YAAyB;;;AAI7F,SAAS,gBACP,WACA,MACA,QACmB;AACnB,KAAI,OAAO,SAAS,UAAU;AAE5B,eADiB,QAAQ,WAAW,aAAa,EAC1B,KAAK;AAC5B,SAAO;;CAET,MAAM,WAAW,QAAQ,WAAW,KAAK,YAAY,aAAa;AAClE,cAAa,UAAU,KAAK,KAAK;CACjC,MAAM,eAAe;CACrB,MAAM,eAAe,cAAc,UAAU;CAC7C,MAAM,eACJ,KAAK,UAGJ;CACH,MAAM,gBAAgB,4BACpB,4BACE,4BACE,4BAA4B,cAAc,cAAc,cAAc,EACtE,4BAA4B,cAAc,cAAc,cAAc,CACvE,EACD;EACE,iBAAiB;EACjB,gBAAgB,EACd,qBAAqB;GAAC;GAAQ;GAAS;GAAQ;GAAQ,EACxD;EACF,CACF,EACD,4BACE,QAAQ,iBAAiB,eACzB,KAAK,iBAAiB,cACvB,CACF;AACD,QAAO;EACL,GAAG;EACH;EACA,UAAU;GACR,GAAG,cAAc;GACjB,GAAG,KAAK;GACR,kBAAkB;IAChB,GAAG,cAAc,UAAU;IAC3B,GAAI,KAAK,UAA8D;IACvE;IACD;GACF;EACD,iBAAiB;GACf,GAAG,QAAQ;GACX,GAAG,KAAK;GACR,eAAe,EACb,GAAG,eACJ;GACF;EACF;;AAGH,SAAS,aAAa,UAAkB,MAAoB;AAC1D,WAAU,QAAQ,SAAS,EAAE,EAAE,WAAW,MAAM,CAAC;AACjD,eAAc,UAAU,KAAK;AAE7B,eADmB,QAAQ,QAAQ,SAAS,EAAE,gBAAgB,EAG5D,KAAK,UACH;EACE,iBAAiB;GACf,QAAQ;GACR,QAAQ;GACR,QAAQ;GACT;EACD,SAAS,CAAC,OAAO;EAClB,EACD,MACA,EACD,CACF;;AAGH,SAAS,gBAAgB,WAAyB;AAChD,aAAY,IAAI,UAAU;AAC1B,KAAI,iBACF;AAEF,oBAAmB;AACnB,SAAQ,GAAG,cAAc;AACvB,OAAK,MAAM,OAAO,YAChB,QAAO,KAAK;GAAE,OAAO;GAAM,WAAW;GAAM,CAAC;GAE/C"}

package/dist/rules/ast.d.ts

@@ -0,0 +1,16 @@
+//#region src/bindings/nodejs/typescript_oxlint/ts/rules/ast.d.ts
+declare function stripChainExpression<Node>(node: Node): Node;
+declare function memberPropertyName(node: unknown): string | undefined;
+declare function memberObject(node: unknown): unknown;
+declare function calleePropertyName(node: unknown): string | undefined;
+declare function isIdentifierNamed(node: unknown, name: string): boolean;
+declare function isNegativeOneLiteral(node: unknown): boolean;
+declare function isZeroLiteral(node: unknown): boolean;
+declare function isLiteralString(node: unknown): boolean;
+declare function isRegExpLiteral(node: unknown): boolean;
+declare function regexFlags(node: unknown): string | undefined;
+declare function hasUnknownTypeAnnotation(node: unknown): boolean;
+declare function nearestFunctionAncestors(node: any, sourceCode: any): any[];
+//#endregion
+export { calleePropertyName, hasUnknownTypeAnnotation, isIdentifierNamed, isLiteralString, isNegativeOneLiteral, isRegExpLiteral, isZeroLiteral, memberObject, memberPropertyName, nearestFunctionAncestors, regexFlags, stripChainExpression };
+//# sourceMappingURL=ast.d.ts.map

package/dist/rules/ast.js

@@ -0,0 +1,56 @@
+//#region src/bindings/nodejs/typescript_oxlint/ts/rules/ast.ts
+function stripChainExpression(node) {
+	let current = node;
+	while (current?.type === "ChainExpression") current = current.expression;
+	return current;
+}
+function memberPropertyName(node) {
+	const current = stripChainExpression(node);
+	if (!current || current.type !== "MemberExpression") return;
+	if (!current.computed && current.property?.type === "Identifier") return current.property.name;
+	if (current.computed && current.property?.type === "Literal") return String(current.property.value);
+}
+function memberObject(node) {
+	const current = stripChainExpression(node);
+	return current?.type === "MemberExpression" ? current.object : void 0;
+}
+function calleePropertyName(node) {
+	const current = stripChainExpression(node);
+	return current?.type === "CallExpression" ? memberPropertyName(current.callee) : void 0;
+}
+function isIdentifierNamed(node, name) {
+	const current = stripChainExpression(node);
+	return current?.type === "Identifier" && current.name === name;
+}
+function isNegativeOneLiteral(node) {
+	const current = stripChainExpression(node);
+	if (current?.type === "Literal" && current.value === -1) return true;
+	return current?.type === "UnaryExpression" && current.operator === "-" && current.argument?.type === "Literal" && current.argument.value === 1;
+}
+function isZeroLiteral(node) {
+	const current = stripChainExpression(node);
+	return current?.type === "Literal" && current.value === 0;
+}
+function isLiteralString(node) {
+	const current = stripChainExpression(node);
+	return current?.type === "Literal" && typeof current.value === "string";
+}
+function isRegExpLiteral(node) {
+	const current = stripChainExpression(node);
+	return current?.type === "Literal" && current.regex !== void 0;
+}
+function regexFlags(node) {
+	const current = stripChainExpression(node);
+	return isRegExpLiteral(current) ? current.regex.flags : void 0;
+}
+function hasUnknownTypeAnnotation(node) {
+	const current = node;
+	return current?.typeAnnotation?.typeAnnotation?.type === "TSUnknownKeyword" || current?.typeAnnotation?.type === "TSUnknownKeyword";
+}
+function nearestFunctionAncestors(node, sourceCode) {
+	return sourceCode.getAncestors(node).toReversed().filter((ancestor) => ancestor.type?.includes("Function"));
+}
+//#endregion
+export { calleePropertyName, hasUnknownTypeAnnotation, isIdentifierNamed, isLiteralString, isNegativeOneLiteral, isRegExpLiteral, isZeroLiteral, memberObject, memberPropertyName, nearestFunctionAncestors, regexFlags, stripChainExpression };
+
+//# sourceMappingURL=ast.js.map

package/dist/rules/ast.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ast.js","names":[],"sources":["../../ts/rules/ast.ts"],"sourcesContent":["export function stripChainExpression<Node>(node: Node): Node {\n  let current = node as any;\n  while (current?.type === \"ChainExpression\") {\n    current = current.expression;\n  }\n  return current as Node;\n}\n\nexport function memberPropertyName(node: unknown): string | undefined {\n  const current = stripChainExpression(node as any) as any;\n  if (!current || current.type !== \"MemberExpression\") {\n    return undefined;\n  }\n  if (!current.computed && current.property?.type === \"Identifier\") {\n    return current.property.name;\n  }\n  if (current.computed && current.property?.type === \"Literal\") {\n    return String(current.property.value);\n  }\n  return undefined;\n}\n\nexport function memberObject(node: unknown): unknown {\n  const current = stripChainExpression(node as any) as any;\n  return current?.type === \"MemberExpression\" ? current.object : undefined;\n}\n\nexport function calleePropertyName(node: unknown): string | undefined {\n  const current = stripChainExpression(node as any) as any;\n  return current?.type === \"CallExpression\" ? memberPropertyName(current.callee) : undefined;\n}\n\nexport function isIdentifierNamed(node: unknown, name: string): boolean {\n  const current = stripChainExpression(node as any) as any;\n  return current?.type === \"Identifier\" && current.name === name;\n}\n\nexport function isNegativeOneLiteral(node: unknown): boolean {\n  const current = stripChainExpression(node as any) as any;\n  if (current?.type === \"Literal\" && current.value === -1) {\n    return true;\n  }\n  return (\n    current?.type === \"UnaryExpression\" &&\n    current.operator === \"-\" &&\n    current.argument?.type === \"Literal\" &&\n    current.argument.value === 1\n  );\n}\n\nexport function isZeroLiteral(node: unknown): boolean {\n  const current = stripChainExpression(node as any) as any;\n  return current?.type === \"Literal\" && current.value === 0;\n}\n\nexport function isLiteralString(node: unknown): boolean {\n  const current = stripChainExpression(node as any) as any;\n  return current?.type === \"Literal\" && typeof current.value === \"string\";\n}\n\nexport function isRegExpLiteral(node: unknown): boolean {\n  const current = stripChainExpression(node as any) as any;\n  return current?.type === \"Literal\" && current.regex !== undefined;\n}\n\nexport function regexFlags(node: unknown): string | undefined {\n  const current = stripChainExpression(node as any) as any;\n  return isRegExpLiteral(current) ? current.regex.flags : undefined;\n}\n\nexport function hasUnknownTypeAnnotation(node: unknown): boolean {\n  const current = node as any;\n  return (\n    current?.typeAnnotation?.typeAnnotation?.type === \"TSUnknownKeyword\" ||\n    current?.typeAnnotation?.type === \"TSUnknownKeyword\"\n  );\n}\n\nexport function nearestFunctionAncestors(node: any, sourceCode: any): any[] {\n  return sourceCode\n    .getAncestors(node)\n    .toReversed()\n    .filter((ancestor: any) => ancestor.type?.includes(\"Function\"));\n}\n"],"mappings":";AAAA,SAAgB,qBAA2B,MAAkB;CAC3D,IAAI,UAAU;AACd,QAAO,SAAS,SAAS,kBACvB,WAAU,QAAQ;AAEpB,QAAO;;AAGT,SAAgB,mBAAmB,MAAmC;CACpE,MAAM,UAAU,qBAAqB,KAAY;AACjD,KAAI,CAAC,WAAW,QAAQ,SAAS,mBAC/B;AAEF,KAAI,CAAC,QAAQ,YAAY,QAAQ,UAAU,SAAS,aAClD,QAAO,QAAQ,SAAS;AAE1B,KAAI,QAAQ,YAAY,QAAQ,UAAU,SAAS,UACjD,QAAO,OAAO,QAAQ,SAAS,MAAM;;AAKzC,SAAgB,aAAa,MAAwB;CACnD,MAAM,UAAU,qBAAqB,KAAY;AACjD,QAAO,SAAS,SAAS,qBAAqB,QAAQ,SAAS,KAAA;;AAGjE,SAAgB,mBAAmB,MAAmC;CACpE,MAAM,UAAU,qBAAqB,KAAY;AACjD,QAAO,SAAS,SAAS,mBAAmB,mBAAmB,QAAQ,OAAO,GAAG,KAAA;;AAGnF,SAAgB,kBAAkB,MAAe,MAAuB;CACtE,MAAM,UAAU,qBAAqB,KAAY;AACjD,QAAO,SAAS,SAAS,gBAAgB,QAAQ,SAAS;;AAG5D,SAAgB,qBAAqB,MAAwB;CAC3D,MAAM,UAAU,qBAAqB,KAAY;AACjD,KAAI,SAAS,SAAS,aAAa,QAAQ,UAAU,GACnD,QAAO;AAET,QACE,SAAS,SAAS,qBAClB,QAAQ,aAAa,OACrB,QAAQ,UAAU,SAAS,aAC3B,QAAQ,SAAS,UAAU;;AAI/B,SAAgB,cAAc,MAAwB;CACpD,MAAM,UAAU,qBAAqB,KAAY;AACjD,QAAO,SAAS,SAAS,aAAa,QAAQ,UAAU;;AAG1D,SAAgB,gBAAgB,MAAwB;CACtD,MAAM,UAAU,qBAAqB,KAAY;AACjD,QAAO,SAAS,SAAS,aAAa,OAAO,QAAQ,UAAU;;AAGjE,SAAgB,gBAAgB,MAAwB;CACtD,MAAM,UAAU,qBAAqB,KAAY;AACjD,QAAO,SAAS,SAAS,aAAa,QAAQ,UAAU,KAAA;;AAG1D,SAAgB,WAAW,MAAmC;CAC5D,MAAM,UAAU,qBAAqB,KAAY;AACjD,QAAO,gBAAgB,QAAQ,GAAG,QAAQ,MAAM,QAAQ,KAAA;;AAG1D,SAAgB,yBAAyB,MAAwB;CAC/D,MAAM,UAAU;AAChB,QACE,SAAS,gBAAgB,gBAAgB,SAAS,sBAClD,SAAS,gBAAgB,SAAS;;AAItC,SAAgB,yBAAyB,MAAW,YAAwB;AAC1E,QAAO,WACJ,aAAa,KAAK,CAClB,YAAY,CACZ,QAAQ,aAAkB,SAAS,MAAM,SAAS,WAAW,CAAC"}

package/dist/rules/await_thenable.d.ts

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

package/dist/rules/await_thenable.js

@@ -0,0 +1,23 @@
+import { isIdentifierNamed, memberObject, memberPropertyName, stripChainExpression } from "./ast.js";
+import { createNativeRule } from "./rule_creator.js";
+import { isPromiseLikeNode } from "./type_utils.js";
+//#region src/bindings/nodejs/typescript_oxlint/ts/rules/await_thenable.ts
+const awaitThenableRule = createNativeRule("await-thenable", {
+	docs: { description: "Disallow awaiting non-thenable values." },
+	messages: { unexpected: "Unexpected await of a non-thenable value." }
+}, (context) => ({ AwaitExpression(node) {
+	if (!isPromiseLikeNode(context, node.argument) && !isObviouslyPromiseLike(node.argument)) context.report({
+		node,
+		messageId: "unexpected"
+	});
+} }));
+function isObviouslyPromiseLike(node) {
+	const current = stripChainExpression(node);
+	if (current?.type === "NewExpression" && isIdentifierNamed(current.callee, "Promise")) return true;
+	if (current?.type !== "CallExpression") return false;
+	return memberPropertyName(current.callee) === "resolve" && isIdentifierNamed(memberObject(current.callee), "Promise");
+}
+//#endregion
+export { awaitThenableRule };
+
+//# sourceMappingURL=await_thenable.js.map

package/dist/rules/await_thenable.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"await_thenable.js","names":[],"sources":["../../ts/rules/await_thenable.ts"],"sourcesContent":["import { isIdentifierNamed, memberObject, memberPropertyName, stripChainExpression } from \"./ast\";\nimport { createNativeRule } from \"./rule_creator\";\nimport { isPromiseLikeNode } from \"./type_utils\";\n\nexport const awaitThenableRule = createNativeRule(\n  \"await-thenable\",\n  {\n    docs: {\n      description: \"Disallow awaiting non-thenable values.\",\n    },\n    messages: {\n      unexpected: \"Unexpected await of a non-thenable value.\",\n    },\n  },\n  (context) => ({\n    AwaitExpression(node: any) {\n      if (!isPromiseLikeNode(context, node.argument) && !isObviouslyPromiseLike(node.argument)) {\n        context.report({ node, messageId: \"unexpected\" });\n      }\n    },\n  }),\n);\n\nfunction isObviouslyPromiseLike(node: any): boolean {\n  const current = stripChainExpression(node);\n  if (current?.type === \"NewExpression\" && isIdentifierNamed(current.callee, \"Promise\")) {\n    return true;\n  }\n  if (current?.type !== \"CallExpression\") {\n    return false;\n  }\n  return (\n    memberPropertyName(current.callee) === \"resolve\" &&\n    isIdentifierNamed(memberObject(current.callee), \"Promise\")\n  );\n}\n"],"mappings":";;;;AAIA,MAAa,oBAAoB,iBAC/B,kBACA;CACE,MAAM,EACJ,aAAa,0CACd;CACD,UAAU,EACR,YAAY,6CACb;CACF,GACA,aAAa,EACZ,gBAAgB,MAAW;AACzB,KAAI,CAAC,kBAAkB,SAAS,KAAK,SAAS,IAAI,CAAC,uBAAuB,KAAK,SAAS,CACtF,SAAQ,OAAO;EAAE;EAAM,WAAW;EAAc,CAAC;GAGtD,EACF;AAED,SAAS,uBAAuB,MAAoB;CAClD,MAAM,UAAU,qBAAqB,KAAK;AAC1C,KAAI,SAAS,SAAS,mBAAmB,kBAAkB,QAAQ,QAAQ,UAAU,CACnF,QAAO;AAET,KAAI,SAAS,SAAS,iBACpB,QAAO;AAET,QACE,mBAAmB,QAAQ,OAAO,KAAK,aACvC,kBAAkB,aAAa,QAAQ,OAAO,EAAE,UAAU"}