@flint.fyi/volar-language 0.0.1 → 0.1.0

package/LICENSE.md

@@ -0,0 +1,20 @@
+# MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+'Software'), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

package/lib/index.d.ts

@@ -0,0 +1,2 @@
+import { Language, createVolarBasedLanguage, reportSourceCode } from "./language.js";
+export { type Language, createVolarBasedLanguage, reportSourceCode };

package/lib/index.js

@@ -0,0 +1,2 @@
+import { createVolarBasedLanguage, reportSourceCode } from "./language.js";
+export { createVolarBasedLanguage, reportSourceCode };

package/lib/language.d.ts

@@ -0,0 +1,35 @@
+import { FileAboutData, FileReport, Language, Language as Language$2, LanguageFileCacheImpacts, LanguageReports, RuleContext, RuleReport } from "@flint.fyi/core";
+import { AST, ExtractedDirective, TypeScriptFileServices, TypeScriptNodesByName } from "@flint.fyi/typescript-language";
+import * as typescript from "typescript";
+import ts from "typescript";
+import { Language as Language$1, LanguagePlugin, SourceScript } from "@volar/language-core";
+import { TypeScriptServiceScript } from "@volar/typescript";
+
+//#region src/language.d.ts
+type VolarLanguagePluginInitializer<FileServices extends object> = (ts: typeof typescript, options: ts.CreateProgramOptions) => {
+  createFile: VolarBasedLanguageCreateFile<FileServices>;
+  languagePlugins: LanguagePlugin<string>[];
+};
+interface VolarBasedLanguageCreateFileContext {
+  data: FileAboutData;
+  program: ts.Program;
+  serviceScript: TypeScriptServiceScript;
+  sourceFile: AST.SourceFile;
+  sourceScript: SourceScript<string> & {
+    generated: NonNullable<SourceScript<string>["generated"]>;
+  };
+  volarLanguage: Language$1;
+}
+type VolarBasedLanguageCreateFile<FileServices extends object> = (ctx: VolarBasedLanguageCreateFileContext) => {
+  cache?: LanguageFileCacheImpacts;
+  directives?: ExtractedDirective[];
+  extraContext?: FileServices;
+  firstStatementPosition: number;
+  getLanguageReports?: () => LanguageReports;
+  reports?: FileReport[];
+};
+declare function createVolarBasedLanguage<FileServices extends object>(initializer: VolarLanguagePluginInitializer<FileServices>): Language<TypeScriptNodesByName, Partial<FileServices> & TypeScriptFileServices>;
+declare function reportSourceCode<T extends string>(context: RuleContext<T>, report: RuleReport<T>): void;
+//#endregion
+export { type Language$2 as Language, createVolarBasedLanguage, reportSourceCode };
+//# sourceMappingURL=language.d.ts.map

package/lib/language.js

@@ -0,0 +1,220 @@
+import { name, version } from "./package.js";
+import { DirectivesCollector, createLanguage, getColumnAndLineOfPosition, isSuggestionForFiles } from "@flint.fyi/core";
+import { setTSProgramCreationProxy } from "@flint.fyi/ts-patch";
+import { NodeSyntaxKinds, convertTypeScriptDiagnosticToLanguageReport, extractDirectivesFromTypeScriptFile, setVolarCreateFile, throwUnknownLanguageExtension, typescriptLanguage } from "@flint.fyi/typescript-language";
+import { FlintAssertionError, assert, nullThrows } from "@flint.fyi/utils";
+import { proxyCreateProgram } from "@volar/typescript/lib/node/proxyCreateProgram.js";
+import ts from "typescript";
+//#region src/language.ts
+const stateSymbol = Symbol.for("@flint.fyi/volar-language/state");
+const globalTyped = globalThis;
+assert(globalTyped[stateSymbol] == null, `Two different versions of ${name} are imported: ${version} and ${globalTyped[stateSymbol]?.packageVersion}`);
+const { pluginInitializers } = globalTyped[stateSymbol] = {
+	packageVersion: version,
+	pluginInitializers: /* @__PURE__ */ new Set()
+};
+setTSProgramCreationProxy((ts, createProgram) => new Proxy(function() {}, { apply(_, thisArg, args) {
+	let volarLanguage = null;
+	const proxied = proxyCreateProgram(ts, new Proxy(createProgram, { apply(target, thisArg, [options]) {
+		assert(options.host != null, "Expected options.host to be defined");
+		const patchedGetSourceFile = options.host.getSourceFile.bind(options.host);
+		options.host.getSourceFile = (...args) => {
+			try {
+				return patchedGetSourceFile(...args);
+			} catch (error) {
+				if (error instanceof Error && error.message === "!!sourceScript") throwUnknownLanguageExtension(args[0]);
+				throw error;
+			}
+		};
+		return Reflect.apply(target, thisArg, args);
+	} }), (ts, options) => {
+		return {
+			languagePlugins: Array.from(pluginInitializers).map((initializer) => initializer(ts, options)).flatMap(({ createFile, languagePlugins }) => languagePlugins.map((plugin) => {
+				if (plugin.typescript == null) return plugin;
+				plugin[stateSymbol] = { createFile };
+				const getServiceScript = plugin.typescript.getServiceScript.bind(plugin.typescript);
+				plugin.typescript.getServiceScript = (root) => {
+					const script = getServiceScript(root);
+					if (script == null) return script;
+					return {
+						...script,
+						preventLeadingOffset: true
+					};
+				};
+				return plugin;
+			})),
+			setup: (lang) => {
+				volarLanguage = lang;
+			}
+		};
+	});
+	const program = Reflect.apply(proxied, thisArg, args);
+	assert(volarLanguage != null, "Expected volarLanguage to be set");
+	program[stateSymbol] ??= { volarLanguage };
+	return program;
+} }));
+setVolarCreateFile((data, program, sourceFile) => {
+	const volarLanguage = nullThrows(program[stateSymbol]?.volarLanguage, "TypeScript wasn't proxied with Volar.js");
+	const sourceScript = volarLanguage.scripts.get(sourceFile.fileName);
+	assert(sourceScript != null, `Volar.js source script for ${sourceFile.fileName} is undefined`);
+	assert(sourceScript.generated != null, `Volar.js sourceScript.generated for ${sourceFile.fileName} is undefined`);
+	assert(sourceScript.generated.languagePlugin.typescript != null, `Volar.js sourceScript.generated.languagePlugin.typescript for ${sourceFile.fileName} is undefined`);
+	const createFile = nullThrows(sourceScript.generated.languagePlugin[stateSymbol]?.createFile, `Volar.js language plugin for script (${sourceFile.fileName}) with language id ${sourceScript.generated.root.languageId} doesn't have __flintCreateFile property`);
+	const sourceText = sourceScript.snapshot.getText(0, sourceScript.snapshot.getLength());
+	const sourceTextWithLineMap = { text: sourceText };
+	function normalizeSourceRange(range) {
+		return {
+			begin: getColumnAndLineOfPosition(sourceTextWithLineMap, range.begin),
+			end: getColumnAndLineOfPosition(sourceTextWithLineMap, range.end)
+		};
+	}
+	const serviceScript = nullThrows(sourceScript.generated.languagePlugin.typescript.getServiceScript(sourceScript.generated.root), `Volar.js service script for ${sourceFile.fileName} is undefined`);
+	const map = volarLanguage.maps.get(serviceScript.code, sourceScript);
+	const sortedMappings = map.mappings.toSorted(({ generatedOffsets: [a] }, { generatedOffsets: [b] }) => {
+		assert(a != null, "Expected generatedOffsets to have at least one element");
+		assert(b != null, "Expected generatedOffsets to have at least one element");
+		return a - b;
+	});
+	const { directives, extraContext, firstStatementPosition, getLanguageReports, reports } = createFile({
+		data,
+		program,
+		serviceScript,
+		sourceFile,
+		sourceScript,
+		volarLanguage
+	});
+	const translatedDirectives = [...directives ?? []];
+	for (const directive of extractDirectivesFromTypeScriptFile(sourceFile)) {
+		const range = translateRange(map, directive.range.begin.raw, directive.range.end.raw);
+		if (range != null) translatedDirectives.push({
+			...directive,
+			range: normalizeSourceRange(range)
+		});
+	}
+	const directivesCollector = new DirectivesCollector(firstStatementPosition);
+	translatedDirectives.sort((a, b) => a.range.begin.raw - b.range.begin.raw);
+	for (const { range, selection, type } of translatedDirectives) directivesCollector.add(range, selection, type);
+	const collected = directivesCollector.collect();
+	return {
+		__volarServices: {
+			runVisitors(file, options, runtime) {
+				const { visitors } = runtime;
+				if (!visitors) return;
+				const visitorServices = {
+					options,
+					...file.services
+				};
+				let lastMappingIdx = 0;
+				const visit = (node) => {
+					const key = NodeSyntaxKinds[node.kind];
+					visitors[key]?.(node, visitorServices);
+					node.forEachChild(visit);
+					visitors[`${key}:exit`]?.(node, visitorServices);
+				};
+				visitors.SourceFile?.(sourceFile, visitorServices);
+				Statements: for (const statement of sourceFile.statements) {
+					while (true) {
+						const currentMapping = sortedMappings[lastMappingIdx];
+						if (currentMapping == null) break Statements;
+						const currentMappingOffset = nullThrows(currentMapping.generatedOffsets[0], "Expected mapping to have at least one generated offset");
+						const currentMappingLength = nullThrows(currentMapping.generatedLengths?.[0] ?? currentMapping.lengths[0], "Expected mapping to have at least one length");
+						if (currentMappingLength === 0 || statement.pos >= currentMappingOffset + currentMappingLength) {
+							lastMappingIdx++;
+							continue;
+						}
+						if (statement.end <= currentMappingOffset) continue Statements;
+						break;
+					}
+					visit(statement);
+				}
+				visit(sourceFile.endOfFileToken);
+			},
+			getLanguageReports() {
+				return [...ts.getPreEmitDiagnostics(program, sourceFile).map((diagnostic) => convertTypeScriptDiagnosticToLanguageReport({
+					...diagnostic,
+					file: diagnostic.file ? {
+						fileName: diagnostic.file.fileName,
+						text: sourceText
+					} : diagnostic.file
+				})), ...getLanguageReports?.() ?? []];
+			}
+		},
+		about: {
+			...data,
+			sourceText
+		},
+		adjustReportRange(range) {
+			if (range.begin < 0) return {
+				begin: -range.begin,
+				end: range.end
+			};
+			return translateRange(map, range.begin, range.end);
+		},
+		directives: collected.directives,
+		language: typescriptLanguage,
+		reports: [...collected.reports, ...reports ?? []],
+		services: {
+			program,
+			sourceFile,
+			typeChecker: program.getTypeChecker(),
+			...extraContext
+		}
+	};
+});
+function createVolarBasedLanguage(initializer) {
+	pluginInitializers.add(initializer);
+	return {
+		...createLanguage({
+			about: { name: "Volar.js-based language" },
+			createFileFactory() {
+				throw new FlintAssertionError("Volar.js based language should never be called directly");
+			},
+			runFileVisitors() {
+				throw new FlintAssertionError("Volar.js based language should never be called directly");
+			}
+		}),
+		createRule: (ruleDefinition) => {
+			return {
+				...ruleDefinition,
+				language: typescriptLanguage
+			};
+		}
+	};
+}
+function reportSourceCode(context, report) {
+	context.report({
+		...report,
+		fix: (report.fix && !Array.isArray(report.fix) ? [report.fix] : report.fix)?.map((change) => ({
+			...change,
+			range: sourceCodeRange(change.range)
+		})),
+		range: sourceCodeRange(report.range),
+		suggestions: report.suggestions?.map((suggestion) => {
+			if (isSuggestionForFiles(suggestion)) return null;
+			return {
+				...suggestion,
+				range: sourceCodeRange(suggestion.range)
+			};
+		}).filter((s) => s != null)
+	});
+}
+function sourceCodeRange(range) {
+	return {
+		begin: -range.begin,
+		end: range.end
+	};
+}
+function translateRange(map, serviceBegin, serviceEnd) {
+	for (const [begin, end] of map.toSourceRange(serviceBegin, serviceEnd, true)) {
+		if (begin === end) continue;
+		return {
+			begin,
+			end
+		};
+	}
+	return null;
+}
+//#endregion
+export { createVolarBasedLanguage, reportSourceCode };
+
+//# sourceMappingURL=language.js.map

package/lib/package.js

@@ -0,0 +1,7 @@
+//#region package.json
+var name = "@flint.fyi/volar-language";
+var version = "0.1.0";
+//#endregion
+export { name, version };
+
+//# sourceMappingURL=package.js.map

package/package.json

@@ -1,10 +1,47 @@
 {
   "name": "@flint.fyi/volar-language",
-  "version": "0.0.1",
-  "description": "OIDC trusted publishing setup package for @flint.fyi/volar-language",
-  "keywords": [
-    "oidc",
-    "trusted-publishing",
-    "setup"
-  ]
-}
+  "version": "0.1.0",
+  "description": "[Experimental] Volar.js language for Flint.",
+  "homepage": "https://flint.fyi",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/flint-fyi/flint.git",
+    "directory": "packages/volar-language"
+  },
+  "license": "MIT",
+  "author": {
+    "name": "JoshuaKGoldberg",
+    "email": "npm@joshuakgoldberg.com"
+  },
+  "sideEffects": true,
+  "type": "module",
+  "exports": {
+    ".": "./lib/index.js"
+  },
+  "files": [
+    "lib/",
+    "!lib/**/*.map"
+  ],
+  "dependencies": {
+    "@volar/language-core": "2.4.28",
+    "@volar/typescript": "2.4.28",
+    "typescript": "^5.9.0 || ^6.0.0",
+    "@flint.fyi/core": "^0.21.0",
+    "@flint.fyi/ts-patch": "^0.13.5",
+    "@flint.fyi/typescript-language": "^0.18.0",
+    "@flint.fyi/utils": "^0.14.1"
+  },
+  "devDependencies": {
+    "tsdown": "0.21.0",
+    "vitest": "4.1.0"
+  },
+  "engines": {
+    "node": ">=24.0.0"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "test": "vitest --project volar-language"
+  }
+}

package/README.md

@@ -1,45 +0,0 @@
-# @flint.fyi/volar-language
-
-## ⚠️ IMPORTANT NOTICE ⚠️
-
-**This package is created solely for the purpose of setting up OIDC (OpenID Connect) trusted publishing with npm.**
-
-This is **NOT** a functional package and contains **NO** code or functionality beyond the OIDC setup configuration.
-
-## Purpose
-
-This package exists to:
-1. Configure OIDC trusted publishing for the package name `@flint.fyi/volar-language`
-2. Enable secure, token-less publishing from CI/CD workflows
-3. Establish provenance for packages published under this name
-
-## What is OIDC Trusted Publishing?
-
-OIDC trusted publishing allows package maintainers to publish packages directly from their CI/CD workflows without needing to manage npm access tokens. Instead, it uses OpenID Connect to establish trust between the CI/CD provider (like GitHub Actions) and npm.
-
-## Setup Instructions
-
-To properly configure OIDC trusted publishing for this package:
-
-1. Go to [npmjs.com](https://www.npmjs.com/) and navigate to your package settings
-2. Configure the trusted publisher (e.g., GitHub Actions)
-3. Specify the repository and workflow that should be allowed to publish
-4. Use the configured workflow to publish your actual package
-
-## DO NOT USE THIS PACKAGE
-
-This package is a placeholder for OIDC configuration only. It:
-- Contains no executable code
-- Provides no functionality
-- Should not be installed as a dependency
-- Exists only for administrative purposes
-
-## More Information
-
-For more details about npm's trusted publishing feature, see:
-- [npm Trusted Publishing Documentation](https://docs.npmjs.com/generating-provenance-statements)
-- [GitHub Actions OIDC Documentation](https://docs.github.com/en/actions/deployment/security-hardening-your-deployments/about-security-hardening-with-openid-connect)
-
----
-
-**Maintained for OIDC setup purposes only**