@flint.fyi/svelte-language 0.0.1 → 0.0.3

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/README.md

@@ -1,45 +1,9 @@
-# @flint.fyi/svelte-language
+<h1 align="center"><code>@flint.fyi/svelte-language</code></h1>
 
-## ⚠️ IMPORTANT NOTICE ⚠️
+<p align="center">
+	[Experimental] Svelte language for Flint.
+	❤️‍🔥
+</p>
 
-**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/svelte-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**
+This is an internal package for Flint.
+Documentation will eventually be added.

package/lib/extractDirectives.d.ts

@@ -0,0 +1,5 @@
+import { type SourceFileWithLineMap } from "@flint.fyi/core";
+import type { ExtractedDirective } from "@flint.fyi/typescript-language";
+import type { AST } from "svelte/compiler";
+export declare function extractDirectives(ast: AST.Root, source: SourceFileWithLineMap): ExtractedDirective[];
+//# sourceMappingURL=extractDirectives.d.ts.map

package/lib/extractDirectives.js

@@ -0,0 +1,27 @@
+import { getColumnAndLineOfPosition } from "@flint.fyi/core";
+import { nullThrows } from "@flint.fyi/utils";
+//#region src/extractDirectives.ts
+function extractDirectives(ast, source) {
+	const directives = [];
+	function visit(node) {
+		if ("fragment" in node) for (const child of node.fragment.nodes) visit(child);
+		if (node.type !== "Comment") return;
+		const match = /\s*flint-(\S+)(?:\s+(.+))?/.exec(node.data);
+		if (match == null) return;
+		const [, type, selection] = match;
+		directives.push({
+			range: {
+				begin: getColumnAndLineOfPosition(source, node.start),
+				end: getColumnAndLineOfPosition(source, node.end)
+			},
+			selection: nullThrows(selection, "Expected RegExp to provide second capturing group"),
+			type: nullThrows(type, "Expected RegExp to provide first capturing group")
+		});
+	}
+	for (const child of ast.fragment.nodes) visit(child);
+	return directives;
+}
+//#endregion
+export { extractDirectives };
+
+//# sourceMappingURL=extractDirectives.js.map

package/lib/index.d.ts

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

package/lib/index.js

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

package/lib/language.d.ts

@@ -0,0 +1,15 @@
+import { AST } from "svelte/compiler";
+import * as _flint_fyi_core0 from "@flint.fyi/core";
+import * as _flint_fyi_typescript_language0 from "@flint.fyi/typescript-language";
+
+//#region src/language.d.ts
+interface SvelteServices {
+  svelte: {
+    ast: AST.Root;
+    sourceText: string;
+  };
+}
+declare const svelteLanguage: _flint_fyi_core0.Language<_flint_fyi_typescript_language0.TypeScriptNodesByName, Partial<SvelteServices> & _flint_fyi_typescript_language0.TypeScriptFileServices>;
+//#endregion
+export { svelteLanguage };
+//# sourceMappingURL=language.d.ts.map

package/lib/language.js

@@ -0,0 +1,65 @@
+import { extractDirectives } from "./extractDirectives.js";
+import { errorToLanguageReport, virtualCodeReports, volarLanguagePlugin } from "./volarLanguagePlugin.js";
+import { setTSExtraSupportedExtensions } from "@flint.fyi/ts-patch";
+import { createVolarBasedLanguage } from "@flint.fyi/volar-language";
+import { parse } from "svelte/compiler";
+//#region src/language.ts
+setTSExtraSupportedExtensions([".svelte"]);
+const svelteLanguage = createVolarBasedLanguage((ts, options) => {
+	return {
+		createFile({ sourceFile, sourceScript }) {
+			const sourceText = sourceScript.snapshot.getText(0, sourceScript.snapshot.getLength());
+			const source = { text: sourceText };
+			const virtualCode = sourceScript.generated.root;
+			let ast;
+			const reports = [];
+			try {
+				ast = parse(sourceText, {
+					loose: true,
+					modern: true
+				});
+			} catch (error) {
+				reports.push(errorToLanguageReport(sourceFile.fileName, error));
+				ast = {
+					comments: [],
+					css: null,
+					end: 0,
+					fragment: {
+						nodes: [],
+						type: "Fragment"
+					},
+					instance: null,
+					module: null,
+					options: null,
+					start: 0,
+					type: "Root"
+				};
+			}
+			const codegenReport = virtualCodeReports.get(virtualCode);
+			if (codegenReport != null) reports.push(codegenReport);
+			return {
+				directives: extractDirectives(ast, source),
+				extraContext: { svelte: {
+					ast,
+					sourceText
+				} },
+				firstStatementPosition: Math.min(...[
+					ast.fragment.nodes.find((node) => node.type !== "Text" || !!node.data.trim().length)?.start,
+					ast.module?.start,
+					ast.instance?.start,
+					ast.css?.start,
+					ast.options?.start,
+					sourceText.length
+				].filter((pos) => typeof pos === "number")),
+				getLanguageReports() {
+					return reports;
+				}
+			};
+		},
+		languagePlugins: [volarLanguagePlugin(ts, options)]
+	};
+});
+//#endregion
+export { svelteLanguage };
+
+//# sourceMappingURL=language.js.map

package/lib/volarLanguagePlugin.d.ts

@@ -0,0 +1,7 @@
+import { type LanguageReport } from "@flint.fyi/core";
+import { type LanguagePlugin, type VirtualCode } from "@volar/language-core";
+import type * as ts from "typescript";
+export declare function volarLanguagePlugin(ts: typeof import("typescript"), options: ts.CreateProgramOptions): LanguagePlugin<string>;
+export declare const virtualCodeReports: WeakMap<VirtualCode, LanguageReport>;
+export declare function errorToLanguageReport(fileName: string, error: unknown): LanguageReport;
+//# sourceMappingURL=volarLanguagePlugin.d.ts.map

package/lib/volarLanguagePlugin.js

@@ -0,0 +1,149 @@
+import { getPositionOfColumnAndLine } from "@flint.fyi/core";
+import { decode } from "@jridgewell/sourcemap-codec";
+import { forEachEmbeddedCode } from "@volar/language-core";
+import path from "node:path";
+import url from "node:url";
+import { internalHelpers, svelte2tsx } from "svelte2tsx";
+//#region src/volarLanguagePlugin.ts
+const sveltePath = path.dirname(url.fileURLToPath(import.meta.resolve("svelte/package.json")));
+const svelte2tsxPath = path.dirname(url.fileURLToPath(import.meta.resolve("svelte2tsx/package.json")));
+function volarLanguagePlugin(ts, options) {
+	const cwd = typeof options.options.configFilePath === "string" ? path.dirname(options.options.configFilePath) : (options.host ?? ts.sys).getCurrentDirectory();
+	return {
+		createVirtualCode(fileName, languageId, snapshot) {
+			if (languageId !== "svelte") return;
+			return {
+				codegenStacks: [],
+				embeddedCodes: [getEmbeddedTsCode(ts, cwd, fileName, snapshot.getText(0, snapshot.getLength()))],
+				id: "root",
+				languageId,
+				mappings: [],
+				snapshot
+			};
+		},
+		getLanguageId(fileName) {
+			if (fileName.endsWith(".svelte")) return "svelte";
+		},
+		typescript: {
+			extraFileExtensions: [{
+				extension: "svelte",
+				isMixedContent: true,
+				scriptKind: 7
+			}],
+			getServiceScript(root) {
+				for (const code of forEachEmbeddedCode(root)) if (code.id === "tsx") return {
+					code,
+					extension: ".tsx",
+					scriptKind: 4
+				};
+			}
+		},
+		updateVirtualCode(fileName, virtualCode, snapshot) {
+			virtualCode.snapshot = snapshot;
+			virtualCode.embeddedCodes = [getEmbeddedTsCode(ts, cwd, fileName, snapshot.getText(0, snapshot.getLength()))];
+			return virtualCode;
+		}
+	};
+}
+const virtualCodeReports = /* @__PURE__ */ new WeakMap();
+function errorToLanguageReport(fileName, error) {
+	if (typeof error !== "object" || error == null) return { text: `${fileName} - Unknown error` };
+	const res = { text: `${fileName}${"position" in error && Array.isArray(error.position) ? `:${error.position[0]}:${error.position[1]}` : ""} - ${"message" in error && typeof error.message === "string" ? error.message : "Codegen error"}` };
+	if ("code" in error && typeof error.code === "string") res.code = error.code;
+	return res;
+}
+function getEmbeddedTsCode(ts, cwd, fileName, text) {
+	const svelteTsxFiles = internalHelpers.get_global_types(ts.sys, false, sveltePath, svelte2tsxPath, cwd);
+	try {
+		const tsx = svelte2tsx(text, {
+			isTsFile: true,
+			mode: "ts"
+		});
+		const v3Mappings = decode(tsx.map.mappings);
+		const sourceTextWithLineMap = { text };
+		const serviceTextWithLineMap = { text: tsx.code };
+		const mappings = [];
+		let current = null;
+		for (const [genLine, segments] of v3Mappings.entries()) for (const segment of segments) {
+			const genCharacter = segment[0];
+			const genOffset = getPositionOfColumnAndLine(serviceTextWithLineMap, {
+				column: genCharacter,
+				line: genLine
+			});
+			if (current != null) {
+				let length = genOffset - current.genOffset;
+				const sourceText = text.substring(current.sourceOffset, current.sourceOffset + length);
+				const genText = tsx.code.substring(current.genOffset, current.genOffset + length);
+				if (sourceText !== genText) {
+					length = 0;
+					for (let i = 0; i < genOffset - current.genOffset; i++) if (sourceText[i] === genText[i]) length = i + 1;
+					else break;
+				}
+				if (length > 0) {
+					const lastMapping = mappings.at(-1);
+					if (lastMapping && current.genOffset === lastMapping.generatedOffsets[0] + lastMapping.lengths[0] && current.sourceOffset === lastMapping.sourceOffsets[0] + lastMapping.lengths[0]) lastMapping.lengths[0] += length;
+					else mappings.push({
+						data: {
+							completion: true,
+							format: false,
+							navigation: true,
+							semantic: true,
+							structure: false,
+							verification: true
+						},
+						generatedOffsets: [current.genOffset],
+						lengths: [length],
+						sourceOffsets: [current.sourceOffset]
+					});
+				}
+				current = null;
+			}
+			if (segment[2] != null && segment[3] != null) current = {
+				genOffset,
+				sourceOffset: getPositionOfColumnAndLine(sourceTextWithLineMap, {
+					column: segment[3],
+					line: segment[2]
+				})
+			};
+		}
+		const codeWithTypes = tsx.code + "\n\n" + svelteTsxFiles.map((p) => `import ${JSON.stringify(p)}`).join("\n");
+		return {
+			embeddedCodes: [],
+			id: "tsx",
+			languageId: "typescriptreact",
+			mappings,
+			snapshot: {
+				getChangeRange() {},
+				getLength() {
+					return codeWithTypes.length;
+				},
+				getText(start, end) {
+					return codeWithTypes.substring(start, end);
+				}
+			}
+		};
+	} catch (error) {
+		const report = errorToLanguageReport(fileName, error);
+		const code = {
+			embeddedCodes: [],
+			id: "tsx",
+			languageId: "typescriptreact",
+			mappings: [],
+			snapshot: {
+				getChangeRange() {},
+				getLength() {
+					return 0;
+				},
+				getText() {
+					return "";
+				}
+			}
+		};
+		virtualCodeReports.set(code, report);
+		return code;
+	}
+}
+//#endregion
+export { errorToLanguageReport, virtualCodeReports, volarLanguagePlugin };
+
+//# sourceMappingURL=volarLanguagePlugin.js.map

package/package.json

@@ -1,10 +1,50 @@
 {
   "name": "@flint.fyi/svelte-language",
-  "version": "0.0.1",
-  "description": "OIDC trusted publishing setup package for @flint.fyi/svelte-language",
-  "keywords": [
-    "oidc",
-    "trusted-publishing",
-    "setup"
-  ]
-}
+  "version": "0.0.3",
+  "description": "[Experimental] Svelte language for Flint.",
+  "homepage": "https://flint.fyi",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/flint-fyi/flint.git",
+    "directory": "packages/svelte-language"
+  },
+  "license": "MIT",
+  "author": {
+    "name": "Flint Team",
+    "url": "https://flint.fyi/team"
+  },
+  "sideEffects": true,
+  "type": "module",
+  "exports": {
+    ".": "./lib/index.js"
+  },
+  "files": [
+    "lib/",
+    "!lib/**/*.map"
+  ],
+  "dependencies": {
+    "@jridgewell/sourcemap-codec": "^1.5.5",
+    "@volar/language-core": "2.4.28",
+    "svelte": "^5.0.0",
+    "svelte2tsx": "^0.7.52",
+    "typescript": "^5.9.0 || ^6.0.0",
+    "@flint.fyi/typescript-language": "^0.18.2",
+    "@flint.fyi/core": "^0.22.0",
+    "@flint.fyi/ts-patch": "^0.13.5",
+    "@flint.fyi/utils": "^0.14.1",
+    "@flint.fyi/volar-language": "^0.1.1"
+  },
+  "devDependencies": {
+    "tsdown": "0.21.0",
+    "vitest": "4.1.0"
+  },
+  "engines": {
+    "node": ">=24.0.0"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "test": "vitest --project svelte-language"
+  }
+}