corsa-oxlint 0.1.0

package/dist/context.d.ts

@@ -0,0 +1,24 @@
+import { ContextWithParserOptions, ResolvedProjectConfig, TypeAwareParserOptions } from "./types.js";
+
+//#region src/bindings/nodejs/typescript_oxlint/ts/context.d.ts
+declare function defaultTsgoExecutable(rootDir: string, platform?: NodeJS.Platform): string;
+declare function resolveProjectConfig(context: ContextWithParserOptions): ResolvedProjectConfig;
+/**
+ * Resolves the type-aware parser options visible to a rule.
+ *
+ * Oxlint exposes a fixed `context.languageOptions.parserOptions` object at
+ * runtime, so `oxlint-plugin-typescript-go` stores its richer configuration under
+ * `settings.typescriptOxlint` and rehydrates the expected
+ * `typescript-eslint`-style shape from there.
+ *
+ * @example
+ * ```ts
+ * const parserOptions = resolveTypeAwareParserOptions(context);
+ * parserOptions.tsgo?.mode;
+ * ```
+ */
+declare function resolveTypeAwareParserOptions(context: ContextWithParserOptions): TypeAwareParserOptions;
+declare function mergeTypeAwareParserOptions(base: TypeAwareParserOptions | undefined, override: TypeAwareParserOptions | undefined): TypeAwareParserOptions;
+//#endregion
+export { defaultTsgoExecutable, mergeTypeAwareParserOptions, resolveProjectConfig, resolveTypeAwareParserOptions };
+//# sourceMappingURL=context.d.ts.map

package/dist/context.js

@@ -0,0 +1,134 @@
+import { existsSync, mkdirSync, writeFileSync } from "node:fs";
+import { dirname, resolve } from "node:path";
+//#region src/bindings/nodejs/typescript_oxlint/ts/context.ts
+const DEFAULT_CACHE_LIFETIME_MS = 250;
+const DEFAULT_PROJECT_PATTERNS = [
+	"*.ts",
+	"*.tsx",
+	"*.js",
+	"*.jsx"
+];
+const DEFAULT_TS_CONFIG = { compilerOptions: {
+	module: "esnext",
+	target: "es2022",
+	strict: true
+} };
+function defaultTsgoExecutable(rootDir, platform = process.platform) {
+	return resolve(rootDir, platform === "win32" ? ".cache/tsgo.exe" : ".cache/tsgo");
+}
+function resolveProjectConfig(context) {
+	const filename = resolve(context.filename);
+	const parserOptions = resolveTypeAwareParserOptions(context);
+	const rootDir = resolve(parserOptions.tsconfigRootDir ?? context.cwd);
+	const runtime = resolveRuntimeOptions(rootDir, parserOptions);
+	const configPath = resolveExplicitProject(rootDir, parserOptions) ?? discoverTsconfig(filename, rootDir) ?? resolveDefaultProject(rootDir, filename, parserOptions.projectService);
+	if (!configPath) throw new Error(`oxlint-plugin-typescript-go could not resolve a tsconfig for ${filename}`);
+	return {
+		filename,
+		rootDir,
+		configPath,
+		runtime
+	};
+}
+/**
+* Resolves the type-aware parser options visible to a rule.
+*
+* Oxlint exposes a fixed `context.languageOptions.parserOptions` object at
+* runtime, so `oxlint-plugin-typescript-go` stores its richer configuration under
+* `settings.typescriptOxlint` and rehydrates the expected
+* `typescript-eslint`-style shape from there.
+*
+* @example
+* ```ts
+* const parserOptions = resolveTypeAwareParserOptions(context);
+* parserOptions.tsgo?.mode;
+* ```
+*/
+function resolveTypeAwareParserOptions(context) {
+	return mergeTypeAwareParserOptions(resolveSettingsParserOptions(context.settings?.typescriptOxlint), mergeTypeAwareParserOptions(context.parserOptions, context.languageOptions?.parserOptions));
+}
+function resolveRuntimeOptions(rootDir, parserOptions) {
+	return {
+		executable: resolve(parserOptions.tsgo?.executable ?? process.env.TSGO_EXECUTABLE ?? defaultTsgoExecutable(rootDir)),
+		cwd: resolve(parserOptions.tsgo?.cwd ?? rootDir),
+		mode: parserOptions.tsgo?.mode ?? "msgpack",
+		cacheLifetimeMs: parserOptions.tsgo?.cacheLifetimeMs ?? DEFAULT_CACHE_LIFETIME_MS
+	};
+}
+function resolveExplicitProject(rootDir, parserOptions) {
+	return asArray(parserOptions.project).map((project) => {
+		return resolve(rootDir, project);
+	}).find(existsSync);
+}
+function discoverTsconfig(filename, rootDir) {
+	let current = dirname(filename);
+	const boundary = resolve(rootDir);
+	while (current.startsWith(boundary)) {
+		const candidate = resolve(current, "tsconfig.json");
+		if (existsSync(candidate)) return candidate;
+		const parent = dirname(current);
+		if (parent === current) break;
+		current = parent;
+	}
+}
+function resolveDefaultProject(rootDir, filename, projectService) {
+	if (!projectService) return;
+	if (projectService !== true && projectService.defaultProject) return resolve(rootDir, projectService.defaultProject);
+	if (!matchesDefaultProject(filename, projectService)) return;
+	const id = Buffer.from(filename).toString("hex").slice(0, 24);
+	const cacheDir = resolve(rootDir, ".cache/typescript_oxlint/default");
+	const configPath = resolve(cacheDir, `${id}.tsconfig.json`);
+	if (!existsSync(configPath)) {
+		mkdirSync(cacheDir, { recursive: true });
+		writeFileSync(configPath, JSON.stringify({
+			...DEFAULT_TS_CONFIG,
+			files: [filename]
+		}, null, 2));
+	}
+	return configPath;
+}
+function matchesDefaultProject(filename, projectService) {
+	return ((projectService === true ? void 0 : projectService.allowDefaultProject) ?? DEFAULT_PROJECT_PATTERNS).some((pattern) => globMatch(filename, pattern));
+}
+function globMatch(value, pattern) {
+	const escaped = pattern.replaceAll(".", "\\.").replaceAll("*", ".*");
+	return new RegExp(`${escaped}$`).test(value);
+}
+function asArray(value) {
+	return value ? Array.isArray(value) ? value : [value] : [];
+}
+function resolveSettingsParserOptions(settings) {
+	if (!settings) return {};
+	const { parserOptions, ...inline } = settings;
+	return mergeTypeAwareParserOptions(inline, parserOptions);
+}
+function mergeTypeAwareParserOptions(base, override) {
+	if (!base) return override ?? {};
+	if (!override) return base;
+	return {
+		...base,
+		...override,
+		project: override.project ?? base.project,
+		projectService: mergeProjectService(base.projectService, override.projectService),
+		tsconfigRootDir: override.tsconfigRootDir ?? base.tsconfigRootDir,
+		tsgo: {
+			...base.tsgo,
+			...override.tsgo
+		}
+	};
+}
+function mergeProjectService(base, override) {
+	if (override === void 0) return base;
+	if (typeof override === "boolean") return override;
+	if (base === void 0 || typeof base === "boolean") return override;
+	return {
+		...base,
+		...override,
+		allowDefaultProject: override.allowDefaultProject ?? base.allowDefaultProject,
+		defaultProject: override.defaultProject ?? base.defaultProject
+	};
+}
+//#endregion
+export { defaultTsgoExecutable, mergeTypeAwareParserOptions, resolveProjectConfig, resolveTypeAwareParserOptions };
+
+//# sourceMappingURL=context.js.map

package/dist/context.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"context.js","names":[],"sources":["../ts/context.ts"],"sourcesContent":["import { existsSync, mkdirSync, writeFileSync } from \"node:fs\";\nimport { dirname, resolve } from \"node:path\";\n\nimport type {\n  ContextWithParserOptions,\n  ProjectServiceOptions,\n  ResolvedProjectConfig,\n  ResolvedRuntimeOptions,\n  TypeAwareParserOptions,\n  TypescriptOxlintSettings,\n} from \"./types\";\n\nconst DEFAULT_CACHE_LIFETIME_MS = 250;\nconst DEFAULT_PROJECT_PATTERNS = [\"*.ts\", \"*.tsx\", \"*.js\", \"*.jsx\"];\nconst DEFAULT_TS_CONFIG = {\n  compilerOptions: {\n    module: \"esnext\",\n    target: \"es2022\",\n    strict: true,\n  },\n};\n\nexport function defaultTsgoExecutable(rootDir: string, platform = process.platform): string {\n  return resolve(rootDir, platform === \"win32\" ? \".cache/tsgo.exe\" : \".cache/tsgo\");\n}\n\nexport function resolveProjectConfig(context: ContextWithParserOptions): ResolvedProjectConfig {\n  const filename = resolve(context.filename);\n  const parserOptions = resolveTypeAwareParserOptions(context);\n  const rootDir = resolve(parserOptions.tsconfigRootDir ?? context.cwd);\n  const runtime = resolveRuntimeOptions(rootDir, parserOptions);\n  const configPath =\n    resolveExplicitProject(rootDir, parserOptions) ??\n    discoverTsconfig(filename, rootDir) ??\n    resolveDefaultProject(rootDir, filename, parserOptions.projectService);\n  if (!configPath) {\n    throw new Error(`oxlint-plugin-typescript-go could not resolve a tsconfig for ${filename}`);\n  }\n  return { filename, rootDir, configPath, runtime };\n}\n\n/**\n * Resolves the type-aware parser options visible to a rule.\n *\n * Oxlint exposes a fixed `context.languageOptions.parserOptions` object at\n * runtime, so `oxlint-plugin-typescript-go` stores its richer configuration under\n * `settings.typescriptOxlint` and rehydrates the expected\n * `typescript-eslint`-style shape from there.\n *\n * @example\n * ```ts\n * const parserOptions = resolveTypeAwareParserOptions(context);\n * parserOptions.tsgo?.mode;\n * ```\n */\nexport function resolveTypeAwareParserOptions(\n  context: ContextWithParserOptions,\n): TypeAwareParserOptions {\n  return mergeTypeAwareParserOptions(\n    resolveSettingsParserOptions(context.settings?.typescriptOxlint),\n    mergeTypeAwareParserOptions(context.parserOptions, context.languageOptions?.parserOptions),\n  );\n}\n\nfunction resolveRuntimeOptions(\n  rootDir: string,\n  parserOptions: TypeAwareParserOptions,\n): ResolvedRuntimeOptions {\n  return {\n    executable: resolve(\n      parserOptions.tsgo?.executable ??\n        process.env.TSGO_EXECUTABLE ??\n        defaultTsgoExecutable(rootDir),\n    ),\n    cwd: resolve(parserOptions.tsgo?.cwd ?? rootDir),\n    mode: parserOptions.tsgo?.mode ?? \"msgpack\",\n    cacheLifetimeMs: parserOptions.tsgo?.cacheLifetimeMs ?? DEFAULT_CACHE_LIFETIME_MS,\n  };\n}\n\nfunction resolveExplicitProject(\n  rootDir: string,\n  parserOptions: TypeAwareParserOptions,\n): string | undefined {\n  const projects = asArray(parserOptions.project).map((project) => {\n    return resolve(rootDir, project);\n  });\n  return projects.find(existsSync);\n}\n\nfunction discoverTsconfig(filename: string, rootDir: string): string | undefined {\n  let current = dirname(filename);\n  const boundary = resolve(rootDir);\n  while (current.startsWith(boundary)) {\n    const candidate = resolve(current, \"tsconfig.json\");\n    if (existsSync(candidate)) {\n      return candidate;\n    }\n    const parent = dirname(current);\n    if (parent === current) {\n      break;\n    }\n    current = parent;\n  }\n  return undefined;\n}\n\nfunction resolveDefaultProject(\n  rootDir: string,\n  filename: string,\n  projectService: boolean | ProjectServiceOptions | undefined,\n): string | undefined {\n  if (!projectService) {\n    return undefined;\n  }\n  if (projectService !== true && projectService.defaultProject) {\n    return resolve(rootDir, projectService.defaultProject);\n  }\n  if (!matchesDefaultProject(filename, projectService as true | ProjectServiceOptions)) {\n    return undefined;\n  }\n  const id = Buffer.from(filename).toString(\"hex\").slice(0, 24);\n  const cacheDir = resolve(rootDir, \".cache/typescript_oxlint/default\");\n  const configPath = resolve(cacheDir, `${id}.tsconfig.json`);\n  if (!existsSync(configPath)) {\n    mkdirSync(cacheDir, { recursive: true });\n    writeFileSync(\n      configPath,\n      JSON.stringify(\n        {\n          ...DEFAULT_TS_CONFIG,\n          files: [filename],\n        },\n        null,\n        2,\n      ),\n    );\n  }\n  return configPath;\n}\n\nfunction matchesDefaultProject(\n  filename: string,\n  projectService: true | ProjectServiceOptions,\n): boolean {\n  const patterns =\n    (projectService === true ? undefined : projectService.allowDefaultProject) ??\n    DEFAULT_PROJECT_PATTERNS;\n  return patterns.some((pattern: string) => globMatch(filename, pattern));\n}\n\nfunction globMatch(value: string, pattern: string): boolean {\n  const escaped = pattern.replaceAll(\".\", \"\\\\.\").replaceAll(\"*\", \".*\");\n  return new RegExp(`${escaped}$`).test(value);\n}\n\nfunction asArray(value: string | string[] | undefined): string[] {\n  return value ? (Array.isArray(value) ? value : [value]) : [];\n}\n\nfunction resolveSettingsParserOptions(\n  settings: TypescriptOxlintSettings | undefined,\n): TypeAwareParserOptions {\n  if (!settings) {\n    return {};\n  }\n  const { parserOptions, ...inline } = settings;\n  return mergeTypeAwareParserOptions(inline, parserOptions);\n}\n\nexport function mergeTypeAwareParserOptions(\n  base: TypeAwareParserOptions | undefined,\n  override: TypeAwareParserOptions | undefined,\n): TypeAwareParserOptions {\n  if (!base) {\n    return override ?? {};\n  }\n  if (!override) {\n    return base;\n  }\n  return {\n    ...base,\n    ...override,\n    project: override.project ?? base.project,\n    projectService: mergeProjectService(base.projectService, override.projectService),\n    tsconfigRootDir: override.tsconfigRootDir ?? base.tsconfigRootDir,\n    tsgo: {\n      ...base.tsgo,\n      ...override.tsgo,\n    },\n  };\n}\n\nfunction mergeProjectService(\n  base: boolean | ProjectServiceOptions | undefined,\n  override: boolean | ProjectServiceOptions | undefined,\n): boolean | ProjectServiceOptions | undefined {\n  if (override === undefined) {\n    return base;\n  }\n  if (typeof override === \"boolean\") {\n    return override;\n  }\n  if (base === undefined || typeof base === \"boolean\") {\n    return override;\n  }\n  return {\n    ...base,\n    ...override,\n    allowDefaultProject: override.allowDefaultProject ?? base.allowDefaultProject,\n    defaultProject: override.defaultProject ?? base.defaultProject,\n  };\n}\n"],"mappings":"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"}

package/dist/eslint_utils.d.ts

@@ -0,0 +1,19 @@
+import { ContextWithParserOptions, ParserServices } from "./types.js";
+import { getParserServices } from "./parser_services.js";
+
+//#region src/bindings/nodejs/typescript_oxlint/ts/eslint_utils.d.ts
+/**
+ * Self-hosted `typescript-eslint`-style utility surface that swaps parser
+ * service access over to tsgo-backed implementations.
+ */
+declare const ESLintUtils: Readonly<{
+  RuleCreator(urlCreator: (ruleName: string) => string): (rule: any) => never;
+  getParserServices(context: ContextWithParserOptions, allowWithoutFullTypeInformation?: boolean): ParserServices;
+}>;
+declare const RuleCreator: (urlCreator: (ruleName: string) => string) => (rule: any) => never;
+declare function applyDefault<Values extends readonly unknown[], Defaults extends readonly unknown[]>(values: Values | undefined, defaults: Defaults): readonly unknown[];
+declare function deepMerge<T>(base: T, override: unknown): T;
+declare function nullThrows<T>(value: T | null | undefined, message?: string): T;
+//#endregion
+export { ESLintUtils, RuleCreator, applyDefault, deepMerge, getParserServices, nullThrows };
+//# sourceMappingURL=eslint_utils.d.ts.map

package/dist/eslint_utils.js

@@ -0,0 +1,48 @@
+import { getParserServices } from "./parser_services.js";
+import { decorateRule } from "./plugin.js";
+//#region src/bindings/nodejs/typescript_oxlint/ts/eslint_utils.ts
+/**
+* Self-hosted `typescript-eslint`-style utility surface that swaps parser
+* service access over to tsgo-backed implementations.
+*/
+const ESLintUtils = Object.freeze({
+	RuleCreator(urlCreator) {
+		return (rule) => {
+			const docs = rule.meta?.docs;
+			return decorateRule({
+				...rule,
+				meta: {
+					...rule.meta,
+					docs: {
+						...docs,
+						url: urlCreator(rule.name)
+					}
+				},
+				defaultOptions: rule.defaultOptions ?? []
+			});
+		};
+	},
+	getParserServices(context, allowWithoutFullTypeInformation = false) {
+		return getParserServices(context, allowWithoutFullTypeInformation);
+	}
+});
+const RuleCreator = ESLintUtils.RuleCreator;
+function applyDefault(values, defaults) {
+	return deepMerge(defaults, values ?? []);
+}
+function deepMerge(base, override) {
+	if (Array.isArray(base) && Array.isArray(override)) return base.map((value, index) => deepMerge(value, override[index]));
+	if (isObject(base) && isObject(override)) return Object.fromEntries([...new Set([...Object.keys(base), ...Object.keys(override)])].map((key) => [key, deepMerge(base[key], override[key])]));
+	return override ?? base;
+}
+function nullThrows(value, message = "Expected value to be present") {
+	if (value == null) throw new Error(message);
+	return value;
+}
+function isObject(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+//#endregion
+export { ESLintUtils, RuleCreator, applyDefault, deepMerge, getParserServices, nullThrows };
+
+//# sourceMappingURL=eslint_utils.js.map

package/dist/eslint_utils.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"eslint_utils.js","names":[],"sources":["../ts/eslint_utils.ts"],"sourcesContent":["import { getParserServices } from \"./parser_services\";\nimport { decorateRule } from \"./plugin\";\nimport type { ContextWithParserOptions } from \"./types\";\n\n/**\n * Self-hosted `typescript-eslint`-style utility surface that swaps parser\n * service access over to tsgo-backed implementations.\n */\nexport const ESLintUtils = Object.freeze({\n  RuleCreator(urlCreator: (ruleName: string) => string) {\n    return (rule: any) => {\n      const docs = rule.meta?.docs;\n      return decorateRule({\n        ...rule,\n        meta: {\n          ...rule.meta,\n          docs: {\n            ...docs,\n            url: urlCreator(rule.name),\n          },\n        },\n        defaultOptions: rule.defaultOptions ?? [],\n      } as never);\n    };\n  },\n  getParserServices(context: ContextWithParserOptions, allowWithoutFullTypeInformation = false) {\n    return getParserServices(context, allowWithoutFullTypeInformation);\n  },\n});\n\nexport const RuleCreator = ESLintUtils.RuleCreator;\nexport { getParserServices } from \"./parser_services\";\n\nexport function applyDefault<\n  Values extends readonly unknown[],\n  Defaults extends readonly unknown[],\n>(values: Values | undefined, defaults: Defaults): readonly unknown[] {\n  return deepMerge(defaults, values ?? []) as readonly unknown[];\n}\n\nexport function deepMerge<T>(base: T, override: unknown): T {\n  if (Array.isArray(base) && Array.isArray(override)) {\n    return base.map((value, index) => deepMerge(value, override[index])) as unknown as T;\n  }\n  if (isObject(base) && isObject(override)) {\n    return Object.fromEntries(\n      [...new Set([...Object.keys(base), ...Object.keys(override)])].map((key) => [\n        key,\n        deepMerge((base as any)[key], (override as any)[key]),\n      ]),\n    ) as T;\n  }\n  return (override ?? base) as T;\n}\n\nexport function nullThrows<T>(\n  value: T | null | undefined,\n  message = \"Expected value to be present\",\n): T {\n  if (value == null) {\n    throw new Error(message);\n  }\n  return value;\n}\n\nfunction isObject(value: unknown): value is Record<string, unknown> {\n  return typeof value === \"object\" && value !== null && !Array.isArray(value);\n}\n"],"mappings":";;;;;;;AAQA,MAAa,cAAc,OAAO,OAAO;CACvC,YAAY,YAA0C;AACpD,UAAQ,SAAc;GACpB,MAAM,OAAO,KAAK,MAAM;AACxB,UAAO,aAAa;IAClB,GAAG;IACH,MAAM;KACJ,GAAG,KAAK;KACR,MAAM;MACJ,GAAG;MACH,KAAK,WAAW,KAAK,KAAK;MAC3B;KACF;IACD,gBAAgB,KAAK,kBAAkB,EAAE;IAC1C,CAAU;;;CAGf,kBAAkB,SAAmC,kCAAkC,OAAO;AAC5F,SAAO,kBAAkB,SAAS,gCAAgC;;CAErE,CAAC;AAEF,MAAa,cAAc,YAAY;AAGvC,SAAgB,aAGd,QAA4B,UAAwC;AACpE,QAAO,UAAU,UAAU,UAAU,EAAE,CAAC;;AAG1C,SAAgB,UAAa,MAAS,UAAsB;AAC1D,KAAI,MAAM,QAAQ,KAAK,IAAI,MAAM,QAAQ,SAAS,CAChD,QAAO,KAAK,KAAK,OAAO,UAAU,UAAU,OAAO,SAAS,OAAO,CAAC;AAEtE,KAAI,SAAS,KAAK,IAAI,SAAS,SAAS,CACtC,QAAO,OAAO,YACZ,CAAC,GAAG,IAAI,IAAI,CAAC,GAAG,OAAO,KAAK,KAAK,EAAE,GAAG,OAAO,KAAK,SAAS,CAAC,CAAC,CAAC,CAAC,KAAK,QAAQ,CAC1E,KACA,UAAW,KAAa,MAAO,SAAiB,KAAK,CACtD,CAAC,CACH;AAEH,QAAQ,YAAY;;AAGtB,SAAgB,WACd,OACA,UAAU,gCACP;AACH,KAAI,SAAS,KACX,OAAM,IAAI,MAAM,QAAQ;AAE1B,QAAO;;AAGT,SAAS,SAAS,OAAkD;AAClE,QAAO,OAAO,UAAU,YAAY,UAAU,QAAQ,CAAC,MAAM,QAAQ,MAAM"}

package/dist/index.d.ts

@@ -0,0 +1,12 @@
+import { ast_utils_d_exports } from "./ast_utils.js";
+import { ContextWithParserOptions, ParserServices, ParserServicesWithTypeInformation, ProjectServiceOptions, TsgoNode, TsgoProgramShape, TsgoSignature, TsgoSymbol, TsgoType, TsgoTypeCheckerShape, TypeAwareParserOptions } from "./types.js";
+import { AST_NODE_TYPES, AST_TOKEN_TYPES, TSESTree } from "./compat.js";
+import { getParserServices } from "./parser_services.js";
+import { ESLintUtils, RuleCreator } from "./eslint_utils.js";
+import { json_schema_d_exports } from "./json_schema.js";
+import { ts_eslint_d_exports, tseslint } from "./ts_eslint.js";
+import { utils_d_exports } from "./utils.js";
+import { definePlugin, defineRule, eslintCompatPlugin } from "./plugin.js";
+import { RuleTester } from "./rule_tester.js";
+import { index_d_exports } from "./rules/index.js";
+export { ast_utils_d_exports as ASTUtils, AST_NODE_TYPES, AST_TOKEN_TYPES, type ContextWithParserOptions, ESLintUtils, json_schema_d_exports as JSONSchema, type ParserServices, type ParserServicesWithTypeInformation, type ProjectServiceOptions, RuleCreator, RuleTester, ts_eslint_d_exports as TSESLint, TSESTree, type TsgoNode, type TsgoProgramShape, type TsgoSignature, type TsgoSymbol, type TsgoType, type TsgoTypeCheckerShape, type TypeAwareParserOptions, utils_d_exports as Utils, definePlugin, defineRule, eslintCompatPlugin, getParserServices, index_d_exports as rules, tseslint };

package/dist/index.js

@@ -0,0 +1,11 @@
+import { ast_utils_exports } from "./ast_utils.js";
+import { AST_NODE_TYPES, AST_TOKEN_TYPES, TSESTree } from "./compat.js";
+import { getParserServices } from "./parser_services.js";
+import { definePlugin, defineRule, eslintCompatPlugin } from "./plugin.js";
+import { ESLintUtils, RuleCreator } from "./eslint_utils.js";
+import { json_schema_exports } from "./json_schema.js";
+import { ts_eslint_exports, tseslint } from "./ts_eslint.js";
+import { utils_exports } from "./utils.js";
+import { RuleTester } from "./rule_tester.js";
+import { rules_exports } from "./rules/index.js";
+export { ast_utils_exports as ASTUtils, AST_NODE_TYPES, AST_TOKEN_TYPES, ESLintUtils, json_schema_exports as JSONSchema, RuleCreator, RuleTester, ts_eslint_exports as TSESLint, TSESTree, utils_exports as Utils, definePlugin, defineRule, eslintCompatPlugin, getParserServices, rules_exports as rules, tseslint };

package/dist/json_schema.d.ts

@@ -0,0 +1,11 @@
+declare namespace json_schema_d_exports {
+  export { JSONSchema, JSONSchema4, tupleSchema };
+}
+type JSONSchema4 = Record<string, unknown>;
+declare function tupleSchema(...items: readonly JSONSchema4[]): JSONSchema4;
+declare const JSONSchema: Readonly<{
+  tupleSchema: typeof tupleSchema;
+}>;
+//#endregion
+export { JSONSchema, JSONSchema4, json_schema_d_exports, tupleSchema };
+//# sourceMappingURL=json_schema.d.ts.map

package/dist/json_schema.js

@@ -0,0 +1,17 @@
+import { __exportAll } from "./_virtual/_rolldown/runtime.js";
+//#region src/bindings/nodejs/typescript_oxlint/ts/json_schema.ts
+var json_schema_exports = /* @__PURE__ */ __exportAll({
+	JSONSchema: () => JSONSchema,
+	tupleSchema: () => tupleSchema
+});
+function tupleSchema(...items) {
+	return {
+		items,
+		type: "array"
+	};
+}
+const JSONSchema = Object.freeze({ tupleSchema });
+//#endregion
+export { JSONSchema, json_schema_exports, tupleSchema };
+
+//# sourceMappingURL=json_schema.js.map

package/dist/json_schema.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"json_schema.js","names":[],"sources":["../ts/json_schema.ts"],"sourcesContent":["export type JSONSchema4 = Record<string, unknown>;\n\nexport function tupleSchema(...items: readonly JSONSchema4[]): JSONSchema4 {\n  return {\n    items,\n    type: \"array\",\n  };\n}\n\nexport const JSONSchema = Object.freeze({\n  tupleSchema,\n});\n"],"mappings":";;;;;;AAEA,SAAgB,YAAY,GAAG,OAA4C;AACzE,QAAO;EACL;EACA,MAAM;EACP;;AAGH,MAAa,aAAa,OAAO,OAAO,EACtC,aACD,CAAC"}

package/dist/node_map.d.ts

@@ -0,0 +1,18 @@
+import { ContextWithParserOptions, TsgoNode } from "./types.js";
+import { Node } from "@oxlint/plugins";
+
+//#region src/bindings/nodejs/typescript_oxlint/ts/node_map.d.ts
+declare function createNodeMaps(context: ContextWithParserOptions): {
+  esTreeNodeToTSNodeMap: {
+    get(node: Node): TsgoNode;
+    has(node: Node): boolean;
+  };
+  tsNodeToESTreeNodeMap: {
+    get(node: TsgoNode): Node;
+    has(node: TsgoNode): boolean;
+  };
+};
+declare function toPosition(node: Node | TsgoNode): number;
+//#endregion
+export { createNodeMaps, toPosition };
+//# sourceMappingURL=node_map.d.ts.map

package/dist/node_map.js

@@ -0,0 +1,52 @@
+//#region src/bindings/nodejs/typescript_oxlint/ts/node_map.ts
+const estreeToTsgo = /* @__PURE__ */ new WeakMap();
+const tsgoToEstree = /* @__PURE__ */ new WeakMap();
+function createNodeMaps(context) {
+	return {
+		esTreeNodeToTSNodeMap: {
+			get(node) {
+				let current = estreeToTsgo.get(node);
+				if (!current) {
+					current = createTsgoNode(context.filename, node);
+					estreeToTsgo.set(node, current);
+					tsgoToEstree.set(current, node);
+				}
+				return current;
+			},
+			has(node) {
+				return estreeToTsgo.has(node);
+			}
+		},
+		tsNodeToESTreeNodeMap: {
+			get(node) {
+				const value = tsgoToEstree.get(node);
+				if (!value) throw new Error("oxlint-plugin-typescript-go could not map tsgo node back to ESTree");
+				return value;
+			},
+			has(node) {
+				return tsgoToEstree.has(node);
+			}
+		}
+	};
+}
+function toPosition(node) {
+	return "pos" in node ? node.pos : assertRange(node)[0];
+}
+function createTsgoNode(fileName, node) {
+	const [pos, end] = assertRange(node);
+	return {
+		fileName,
+		pos,
+		end,
+		range: [pos, end]
+	};
+}
+function assertRange(node) {
+	const range = node.range;
+	if (!range) throw new Error("oxlint-plugin-typescript-go requires ESTree nodes with range data");
+	return range;
+}
+//#endregion
+export { createNodeMaps, toPosition };
+
+//# sourceMappingURL=node_map.js.map

package/dist/node_map.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"node_map.js","names":[],"sources":["../ts/node_map.ts"],"sourcesContent":["import type { Node } from \"@oxlint/plugins\";\n\nimport type { ContextWithParserOptions, TsgoNode } from \"./types\";\n\nconst estreeToTsgo = new WeakMap<object, TsgoNode>();\nconst tsgoToEstree = new WeakMap<object, Node>();\n\nexport function createNodeMaps(context: ContextWithParserOptions): {\n  esTreeNodeToTSNodeMap: {\n    get(node: Node): TsgoNode;\n    has(node: Node): boolean;\n  };\n  tsNodeToESTreeNodeMap: {\n    get(node: TsgoNode): Node;\n    has(node: TsgoNode): boolean;\n  };\n} {\n  return {\n    esTreeNodeToTSNodeMap: {\n      get(node) {\n        let current = estreeToTsgo.get(node);\n        if (!current) {\n          current = createTsgoNode(context.filename, node);\n          estreeToTsgo.set(node, current);\n          tsgoToEstree.set(current, node);\n        }\n        return current;\n      },\n      has(node) {\n        return estreeToTsgo.has(node);\n      },\n    },\n    tsNodeToESTreeNodeMap: {\n      get(node) {\n        const value = tsgoToEstree.get(node);\n        if (!value) {\n          throw new Error(\"oxlint-plugin-typescript-go could not map tsgo node back to ESTree\");\n        }\n        return value;\n      },\n      has(node) {\n        return tsgoToEstree.has(node);\n      },\n    },\n  };\n}\n\nexport function toPosition(node: Node | TsgoNode): number {\n  return \"pos\" in node ? node.pos : assertRange(node)[0];\n}\n\nfunction createTsgoNode(fileName: string, node: Node): TsgoNode {\n  const [pos, end] = assertRange(node);\n  return {\n    fileName,\n    pos,\n    end,\n    range: [pos, end],\n  };\n}\n\nfunction assertRange(node: Node): readonly [number, number] {\n  const range = (node as Node & { range?: readonly [number, number] }).range;\n  if (!range) {\n    throw new Error(\"oxlint-plugin-typescript-go requires ESTree nodes with range data\");\n  }\n  return range;\n}\n"],"mappings":";AAIA,MAAM,+BAAe,IAAI,SAA2B;AACpD,MAAM,+BAAe,IAAI,SAAuB;AAEhD,SAAgB,eAAe,SAS7B;AACA,QAAO;EACL,uBAAuB;GACrB,IAAI,MAAM;IACR,IAAI,UAAU,aAAa,IAAI,KAAK;AACpC,QAAI,CAAC,SAAS;AACZ,eAAU,eAAe,QAAQ,UAAU,KAAK;AAChD,kBAAa,IAAI,MAAM,QAAQ;AAC/B,kBAAa,IAAI,SAAS,KAAK;;AAEjC,WAAO;;GAET,IAAI,MAAM;AACR,WAAO,aAAa,IAAI,KAAK;;GAEhC;EACD,uBAAuB;GACrB,IAAI,MAAM;IACR,MAAM,QAAQ,aAAa,IAAI,KAAK;AACpC,QAAI,CAAC,MACH,OAAM,IAAI,MAAM,qEAAqE;AAEvF,WAAO;;GAET,IAAI,MAAM;AACR,WAAO,aAAa,IAAI,KAAK;;GAEhC;EACF;;AAGH,SAAgB,WAAW,MAA+B;AACxD,QAAO,SAAS,OAAO,KAAK,MAAM,YAAY,KAAK,CAAC;;AAGtD,SAAS,eAAe,UAAkB,MAAsB;CAC9D,MAAM,CAAC,KAAK,OAAO,YAAY,KAAK;AACpC,QAAO;EACL;EACA;EACA;EACA,OAAO,CAAC,KAAK,IAAI;EAClB;;AAGH,SAAS,YAAY,MAAuC;CAC1D,MAAM,QAAS,KAAsD;AACrE,KAAI,CAAC,MACH,OAAM,IAAI,MAAM,oEAAoE;AAEtF,QAAO"}

package/dist/parser_services.d.ts

@@ -0,0 +1,16 @@
+import { ContextWithParserOptions, ParserServices } from "./types.js";
+
+//#region src/bindings/nodejs/typescript_oxlint/ts/parser_services.d.ts
+/**
+ * Returns `typescript-eslint`-style parser services backed by tsgo.
+ *
+ * @example
+ * ```ts
+ * const services = getParserServices(context);
+ * const checker = services.program.getTypeChecker();
+ * ```
+ */
+declare function getParserServices(context: ContextWithParserOptions, allowWithoutFullTypeInformation?: boolean): ParserServices;
+//#endregion
+export { getParserServices };
+//# sourceMappingURL=parser_services.d.ts.map

package/dist/parser_services.js

@@ -0,0 +1,48 @@
+import { createNodeMaps } from "./node_map.js";
+import { createProgram, createTypeChecker } from "./checker.js";
+//#region src/bindings/nodejs/typescript_oxlint/ts/parser_services.ts
+const parserServices = /* @__PURE__ */ new WeakMap();
+/**
+* Returns `typescript-eslint`-style parser services backed by tsgo.
+*
+* @example
+* ```ts
+* const services = getParserServices(context);
+* const checker = services.program.getTypeChecker();
+* ```
+*/
+function getParserServices(context, allowWithoutFullTypeInformation = false) {
+	const current = parserServices.get(context);
+	if (current) return current;
+	try {
+		const maps = createNodeMaps(context);
+		const services = {
+			program: createProgram(context),
+			...maps,
+			hasFullTypeInformation: true,
+			getTypeAtLocation(node) {
+				return createTypeChecker(context).getTypeAtLocation(node);
+			},
+			getSymbolAtLocation(node) {
+				return createTypeChecker(context).getSymbolAtLocation(node);
+			}
+		};
+		parserServices.set(context, services);
+		return services;
+	} catch (error) {
+		if (!allowWithoutFullTypeInformation) throw error;
+		const fallback = {
+			program: createProgram(context),
+			...createNodeMaps(context),
+			hasFullTypeInformation: false,
+			getTypeAtLocation() {},
+			getSymbolAtLocation() {}
+		};
+		parserServices.set(context, fallback);
+		return fallback;
+	}
+}
+//#endregion
+export { getParserServices };
+
+//# sourceMappingURL=parser_services.js.map

package/dist/parser_services.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"parser_services.js","names":[],"sources":["../ts/parser_services.ts"],"sourcesContent":["import { createProgram, createTypeChecker } from \"./checker\";\nimport { createNodeMaps } from \"./node_map\";\nimport type {\n  ContextWithParserOptions,\n  ParserServices,\n  ParserServicesWithTypeInformation,\n} from \"./types\";\n\nconst parserServices = new WeakMap<object, ParserServices>();\n\n/**\n * Returns `typescript-eslint`-style parser services backed by tsgo.\n *\n * @example\n * ```ts\n * const services = getParserServices(context);\n * const checker = services.program.getTypeChecker();\n * ```\n */\nexport function getParserServices(\n  context: ContextWithParserOptions,\n  allowWithoutFullTypeInformation = false,\n): ParserServices {\n  const current = parserServices.get(context);\n  if (current) {\n    return current;\n  }\n  try {\n    const maps = createNodeMaps(context);\n    const program = createProgram(context);\n    const services: ParserServicesWithTypeInformation = {\n      program,\n      ...maps,\n      hasFullTypeInformation: true,\n      getTypeAtLocation(node) {\n        return createTypeChecker(context).getTypeAtLocation(node);\n      },\n      getSymbolAtLocation(node) {\n        return createTypeChecker(context).getSymbolAtLocation(node);\n      },\n    };\n    parserServices.set(context, services);\n    return services;\n  } catch (error) {\n    if (!allowWithoutFullTypeInformation) {\n      throw error;\n    }\n    const fallback: ParserServices = {\n      program: createProgram(context),\n      ...createNodeMaps(context),\n      hasFullTypeInformation: false,\n      getTypeAtLocation() {\n        return undefined;\n      },\n      getSymbolAtLocation() {\n        return undefined;\n      },\n    };\n    parserServices.set(context, fallback);\n    return fallback;\n  }\n}\n"],"mappings":";;;AAQA,MAAM,iCAAiB,IAAI,SAAiC;;;;;;;;;;AAW5D,SAAgB,kBACd,SACA,kCAAkC,OAClB;CAChB,MAAM,UAAU,eAAe,IAAI,QAAQ;AAC3C,KAAI,QACF,QAAO;AAET,KAAI;EACF,MAAM,OAAO,eAAe,QAAQ;EAEpC,MAAM,WAA8C;GAClD,SAFc,cAAc,QAAQ;GAGpC,GAAG;GACH,wBAAwB;GACxB,kBAAkB,MAAM;AACtB,WAAO,kBAAkB,QAAQ,CAAC,kBAAkB,KAAK;;GAE3D,oBAAoB,MAAM;AACxB,WAAO,kBAAkB,QAAQ,CAAC,oBAAoB,KAAK;;GAE9D;AACD,iBAAe,IAAI,SAAS,SAAS;AACrC,SAAO;UACA,OAAO;AACd,MAAI,CAAC,gCACH,OAAM;EAER,MAAM,WAA2B;GAC/B,SAAS,cAAc,QAAQ;GAC/B,GAAG,eAAe,QAAQ;GAC1B,wBAAwB;GACxB,oBAAoB;GAGpB,sBAAsB;GAGvB;AACD,iBAAe,IAAI,SAAS,SAAS;AACrC,SAAO"}

package/dist/plugin.d.ts

@@ -0,0 +1,26 @@
+import { Plugin, Rule } from "@oxlint/plugins";
+
+//#region src/bindings/nodejs/typescript_oxlint/ts/plugin.d.ts
+type PluginShape = Plugin;
+type RuleShape = Rule;
+declare function definePlugin<Plugin extends PluginShape>(plugin: Plugin): Plugin;
+/**
+ * Defines a single Oxlint rule with `typescript-eslint`-style parser services.
+ *
+ * @example
+ * ```ts
+ * export default defineRule({
+ *   meta: { schema: [], messages: { demo: "demo" } },
+ *   create(context) {
+ *     const services = context.parserServices;
+ *     return {};
+ *   },
+ * });
+ * ```
+ */
+declare function defineRule<Rule extends RuleShape>(rule: Rule): Rule;
+declare function eslintCompatPlugin<Plugin extends PluginShape>(plugin: Plugin): Plugin;
+declare function decorateRule<Rule extends RuleShape>(rule: Rule): Rule;
+//#endregion
+export { decorateRule, definePlugin, defineRule, eslintCompatPlugin };
+//# sourceMappingURL=plugin.d.ts.map

package/dist/plugin.js

@@ -0,0 +1,83 @@
+import { resolveTypeAwareParserOptions } from "./context.js";
+import { getParserServices } from "./parser_services.js";
+import { definePlugin as definePlugin$1, defineRule as defineRule$1, eslintCompatPlugin as eslintCompatPlugin$1 } from "@oxlint/plugins";
+//#region src/bindings/nodejs/typescript_oxlint/ts/plugin.ts
+function definePlugin(plugin) {
+	return definePlugin$1({
+		...plugin,
+		rules: wrapRules(plugin.rules ?? {})
+	});
+}
+/**
+* Defines a single Oxlint rule with `typescript-eslint`-style parser services.
+*
+* @example
+* ```ts
+* export default defineRule({
+*   meta: { schema: [], messages: { demo: "demo" } },
+*   create(context) {
+*     const services = context.parserServices;
+*     return {};
+*   },
+* });
+* ```
+*/
+function defineRule(rule) {
+	return defineRule$1(decorateRule(rule));
+}
+function eslintCompatPlugin(plugin) {
+	return eslintCompatPlugin$1(definePlugin(plugin));
+}
+function decorateRule(rule) {
+	if (rule.create) return {
+		...rule,
+		create(context) {
+			return rule.create(decorateContext(context));
+		}
+	};
+	if ("createOnce" in rule && typeof rule.createOnce === "function") return {
+		...rule,
+		createOnce(context) {
+			return rule.createOnce(decorateContext(context));
+		}
+	};
+	return rule;
+}
+function wrapRules(rules) {
+	return Object.fromEntries(Object.entries(rules).map(([name, rule]) => [name, decorateRule(rule)]));
+}
+function decorateContext(context) {
+	const parserOptions = Object.freeze(resolveTypeAwareParserOptions(context));
+	const baseLanguageOptions = context.languageOptions;
+	const languageOptions = Object.freeze({
+		...baseLanguageOptions,
+		parserOptions
+	});
+	return Object.create(context, {
+		languageOptions: {
+			configurable: true,
+			enumerable: true,
+			get() {
+				return languageOptions;
+			}
+		},
+		parserOptions: {
+			configurable: true,
+			enumerable: false,
+			get() {
+				return parserOptions;
+			}
+		},
+		parserServices: {
+			configurable: true,
+			enumerable: false,
+			get() {
+				return getParserServices(context);
+			}
+		}
+	});
+}
+//#endregion
+export { decorateRule, definePlugin, defineRule, eslintCompatPlugin };
+
+//# sourceMappingURL=plugin.js.map

package/dist/plugin.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"plugin.js","names":["defineOxlintPlugin","defineOxlintRule","oxlintEslintCompatPlugin"],"sources":["../ts/plugin.ts"],"sourcesContent":["import {\n  type Context as OxlintContext,\n  type Plugin as OxlintPlugin,\n  type Rule as OxlintRule,\n  definePlugin as defineOxlintPlugin,\n  defineRule as defineOxlintRule,\n  eslintCompatPlugin as oxlintEslintCompatPlugin,\n} from \"@oxlint/plugins\";\n\nimport { resolveTypeAwareParserOptions } from \"./context\";\nimport { getParserServices } from \"./parser_services\";\nimport type { ContextWithParserOptions, ParserServices } from \"./types\";\n\ntype PluginShape = OxlintPlugin;\ntype RuleShape = OxlintRule;\n\nexport function definePlugin<Plugin extends PluginShape>(plugin: Plugin): Plugin {\n  return defineOxlintPlugin({\n    ...plugin,\n    rules: wrapRules(plugin.rules ?? {}),\n  } as OxlintPlugin) as Plugin;\n}\n\n/**\n * Defines a single Oxlint rule with `typescript-eslint`-style parser services.\n *\n * @example\n * ```ts\n * export default defineRule({\n *   meta: { schema: [], messages: { demo: \"demo\" } },\n *   create(context) {\n *     const services = context.parserServices;\n *     return {};\n *   },\n * });\n * ```\n */\nexport function defineRule<Rule extends RuleShape>(rule: Rule): Rule {\n  return defineOxlintRule(decorateRule(rule) as OxlintRule) as Rule;\n}\n\nexport function eslintCompatPlugin<Plugin extends PluginShape>(plugin: Plugin): Plugin {\n  return oxlintEslintCompatPlugin(definePlugin(plugin)) as Plugin;\n}\n\nexport function decorateRule<Rule extends RuleShape>(rule: Rule): Rule {\n  if (rule.create) {\n    return {\n      ...rule,\n      create(context) {\n        return rule.create!(decorateContext(context));\n      },\n    } as Rule;\n  }\n  if (\"createOnce\" in rule && typeof (rule as any).createOnce === \"function\") {\n    return {\n      ...rule,\n      createOnce(context) {\n        return (rule as any).createOnce(decorateContext(context));\n      },\n    } as Rule;\n  }\n  return rule;\n}\n\nfunction wrapRules(rules: Record<string, RuleShape>): Record<string, RuleShape> {\n  return Object.fromEntries(\n    Object.entries(rules).map(([name, rule]) => [name, decorateRule(rule)]),\n  );\n}\n\nfunction decorateContext(context: ContextWithParserOptions): ContextWithParserOptions {\n  const parserOptions = Object.freeze(resolveTypeAwareParserOptions(context));\n  const baseLanguageOptions = context.languageOptions;\n  const languageOptions = Object.freeze({\n    ...baseLanguageOptions,\n    parserOptions,\n  });\n  return Object.create(context as OxlintContext, {\n    languageOptions: {\n      configurable: true,\n      enumerable: true,\n      get() {\n        return languageOptions;\n      },\n    },\n    parserOptions: {\n      configurable: true,\n      enumerable: false,\n      get() {\n        return parserOptions;\n      },\n    },\n    parserServices: {\n      configurable: true,\n      enumerable: false,\n      get(): ParserServices {\n        return getParserServices(context);\n      },\n    },\n  }) as ContextWithParserOptions;\n}\n"],"mappings":";;;;AAgBA,SAAgB,aAAyC,QAAwB;AAC/E,QAAOA,eAAmB;EACxB,GAAG;EACH,OAAO,UAAU,OAAO,SAAS,EAAE,CAAC;EACrC,CAAiB;;;;;;;;;;;;;;;;AAiBpB,SAAgB,WAAmC,MAAkB;AACnE,QAAOC,aAAiB,aAAa,KAAK,CAAe;;AAG3D,SAAgB,mBAA+C,QAAwB;AACrF,QAAOC,qBAAyB,aAAa,OAAO,CAAC;;AAGvD,SAAgB,aAAqC,MAAkB;AACrE,KAAI,KAAK,OACP,QAAO;EACL,GAAG;EACH,OAAO,SAAS;AACd,UAAO,KAAK,OAAQ,gBAAgB,QAAQ,CAAC;;EAEhD;AAEH,KAAI,gBAAgB,QAAQ,OAAQ,KAAa,eAAe,WAC9D,QAAO;EACL,GAAG;EACH,WAAW,SAAS;AAClB,UAAQ,KAAa,WAAW,gBAAgB,QAAQ,CAAC;;EAE5D;AAEH,QAAO;;AAGT,SAAS,UAAU,OAA6D;AAC9E,QAAO,OAAO,YACZ,OAAO,QAAQ,MAAM,CAAC,KAAK,CAAC,MAAM,UAAU,CAAC,MAAM,aAAa,KAAK,CAAC,CAAC,CACxE;;AAGH,SAAS,gBAAgB,SAA6D;CACpF,MAAM,gBAAgB,OAAO,OAAO,8BAA8B,QAAQ,CAAC;CAC3E,MAAM,sBAAsB,QAAQ;CACpC,MAAM,kBAAkB,OAAO,OAAO;EACpC,GAAG;EACH;EACD,CAAC;AACF,QAAO,OAAO,OAAO,SAA0B;EAC7C,iBAAiB;GACf,cAAc;GACd,YAAY;GACZ,MAAM;AACJ,WAAO;;GAEV;EACD,eAAe;GACb,cAAc;GACd,YAAY;GACZ,MAAM;AACJ,WAAO;;GAEV;EACD,gBAAgB;GACd,cAAc;GACd,YAAY;GACZ,MAAsB;AACpB,WAAO,kBAAkB,QAAQ;;GAEpC;EACF,CAAC"}

package/dist/registry.d.ts

@@ -0,0 +1,12 @@
+import { ContextWithParserOptions } from "./types.js";
+import { resolveProjectConfig } from "./context.js";
+import { TsgoProjectSession } from "./session.js";
+
+//#region src/bindings/nodejs/typescript_oxlint/ts/registry.d.ts
+declare function sessionForContext(context: ContextWithParserOptions): {
+  project: ReturnType<typeof resolveProjectConfig>;
+  session: TsgoProjectSession;
+};
+//#endregion
+export { sessionForContext };
+//# sourceMappingURL=registry.d.ts.map

package/dist/registry.js

@@ -0,0 +1,35 @@
+import { resolveProjectConfig } from "./context.js";
+import { TsgoProjectSession } from "./session.js";
+//#region src/bindings/nodejs/typescript_oxlint/ts/registry.ts
+const sessions = /* @__PURE__ */ new Map();
+let installedExitHook = false;
+function sessionForContext(context) {
+	const project = resolveProjectConfig(context);
+	const key = [
+		project.configPath,
+		project.runtime.executable,
+		project.runtime.cwd,
+		project.runtime.mode
+	].join("::");
+	let session = sessions.get(key);
+	if (!session) {
+		session = new TsgoProjectSession(project, project.runtime);
+		sessions.set(key, session);
+	}
+	installExitHook();
+	return {
+		project,
+		session
+	};
+}
+function installExitHook() {
+	if (installedExitHook) return;
+	installedExitHook = true;
+	process.on("exit", () => {
+		for (const session of sessions.values()) session.close();
+	});
+}
+//#endregion
+export { sessionForContext };
+
+//# sourceMappingURL=registry.js.map

package/dist/registry.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"registry.js","names":[],"sources":["../ts/registry.ts"],"sourcesContent":["import type { ContextWithParserOptions } from \"./types\";\nimport { resolveProjectConfig } from \"./context\";\nimport { TsgoProjectSession } from \"./session\";\n\nconst sessions = new Map<string, TsgoProjectSession>();\nlet installedExitHook = false;\n\nexport function sessionForContext(context: ContextWithParserOptions): {\n  project: ReturnType<typeof resolveProjectConfig>;\n  session: TsgoProjectSession;\n} {\n  const project = resolveProjectConfig(context);\n  const key = [\n    project.configPath,\n    project.runtime.executable,\n    project.runtime.cwd,\n    project.runtime.mode,\n  ].join(\"::\");\n  let session = sessions.get(key);\n  if (!session) {\n    session = new TsgoProjectSession(project, project.runtime);\n    sessions.set(key, session);\n  }\n  installExitHook();\n  return { project, session };\n}\n\nfunction installExitHook(): void {\n  if (installedExitHook) {\n    return;\n  }\n  installedExitHook = true;\n  process.on(\"exit\", () => {\n    for (const session of sessions.values()) {\n      session.close();\n    }\n  });\n}\n"],"mappings":";;;AAIA,MAAM,2BAAW,IAAI,KAAiC;AACtD,IAAI,oBAAoB;AAExB,SAAgB,kBAAkB,SAGhC;CACA,MAAM,UAAU,qBAAqB,QAAQ;CAC7C,MAAM,MAAM;EACV,QAAQ;EACR,QAAQ,QAAQ;EAChB,QAAQ,QAAQ;EAChB,QAAQ,QAAQ;EACjB,CAAC,KAAK,KAAK;CACZ,IAAI,UAAU,SAAS,IAAI,IAAI;AAC/B,KAAI,CAAC,SAAS;AACZ,YAAU,IAAI,mBAAmB,SAAS,QAAQ,QAAQ;AAC1D,WAAS,IAAI,KAAK,QAAQ;;AAE5B,kBAAiB;AACjB,QAAO;EAAE;EAAS;EAAS;;AAG7B,SAAS,kBAAwB;AAC/B,KAAI,kBACF;AAEF,qBAAoB;AACpB,SAAQ,GAAG,cAAc;AACvB,OAAK,MAAM,WAAW,SAAS,QAAQ,CACrC,SAAQ,OAAO;GAEjB"}