@ripple-ts/language-server 0.3.93 → 0.3.95

package/dist/language-server.js

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-const require_server = require('./server-D9tbDqrh.js');
+const require_server = require('./server-DhFWQsiH.js');
 
 //#region src/language-server.js
 require_server.createRippleLanguageServer();

package/dist/{server-D9tbDqrh.js → server-DhFWQsiH.js}

@@ -851,6 +851,32 @@ function getRippleLanguagePlugin() {
 					extension: ".tsx",
 					scriptKind: 4
 				};
+			},
+			/**
+			* Register each embedded `<script>` body as its own TypeScript service
+			* script so volar-service-typescript's semantic features (type-aware
+			* completions, hover, go-to-definition, diagnostics, imports) run against it
+			* and map back to the `.tsrx` source — the same way `<style>` bodies get CSS
+			* intellisense, except semantic TS additionally requires a service-script
+			* registration (a self-contained languageId is not enough).
+			*
+			* The returned `code` must be the exact same instance stored in the root's
+			* `embeddedCodes` (volar matches it by identity), and each `fileName` must be
+			* unique. Only honored on the language-server (`createTypeScriptProject`)
+			* path, not the tsserver-plugin path.
+			* @param {string} fileName
+			* @param {VirtualCode} ripple_code
+			*/
+			getExtraServiceScripts(fileName, ripple_code) {
+				/** @type {Array<{ fileName: string, code: VirtualCode, extension: string, scriptKind: number }>} */
+				const scripts = [];
+				for (const code of (0, import_language_core.forEachEmbeddedCode)(ripple_code)) if (code.languageId === "typescript") scripts.push({
+					fileName: `${fileName}.${code.id}.ts`,
+					code,
+					extension: ".ts",
+					scriptKind: typescript.default.ScriptKind.TS
+				});
+				return scripts;
 			}
 		}
 	};
@@ -983,25 +1009,14 @@ var TSRXVirtualCode = class {
 			this.sourceAst = transpiled.sourceAst;
 			if (process.env.TSRX_TSC === "true" && transpiled.errors.length > 0) logTSRXErrors(this.fileName, transpiled.errors);
 			const cssMappings = transpiled.cssMappings;
-			if (cssMappings.length > 0) {
-				log$9("Creating", cssMappings.length, "CSS embedded codes");
-				this.embeddedCodes = cssMappings.map((mapping, index) => {
-					const cssContent = mapping.data?.customData?.content;
-					log$9(`CSS region ${index}: \
-						offset ${mapping.sourceOffsets[0]}-${mapping.sourceOffsets[0] + mapping.lengths[0]}, \
-						length ${mapping.lengths[0]}`);
-					return {
-						id: mapping.data?.customData?.embeddedId,
-						languageId: "css",
-						snapshot: {
-							getText: (start, end) => cssContent.substring(start, end),
-							getLength: () => mapping.lengths[0],
-							getChangeRange: () => void 0
-						},
-						mappings: [mapping],
-						embeddedCodes: []
-					};
-				});
+			const scriptMappings = transpiled.scriptMappings ?? [];
+			if (cssMappings.length > 0 || scriptMappings.length > 0) {
+				log$9("Creating", cssMappings.length, "CSS and", scriptMappings.length, "script embedded codes");
+				/** @type {VirtualCode[]} */
+				const embedded = [];
+				for (const mapping of cssMappings) embedded.push(create_embedded_code_from_mapping(mapping, "css"));
+				for (const mapping of scriptMappings) embedded.push(create_embedded_code_from_mapping(mapping, "typescript"));
+				this.embeddedCodes = embedded;
 			} else this.embeddedCodes = [];
 			if (DEBUG) {
 				log$9("CSS embedded codes:", (this.embeddedCodes || []).length);
@@ -1037,7 +1052,7 @@ var TSRXVirtualCode = class {
 					customData: {}
 				}
 			}];
-			this.embeddedCodes = extractCssFromSource(newCode);
+			this.embeddedCodes = [...extractCssFromSource(newCode), ...extractScriptFromSource(newCode)];
 			this.snapshot = {
 				getText: (start, end) => this.generatedCode.substring(start, end),
 				getLength: () => this.generatedCode.length,
@@ -1201,6 +1216,79 @@ function extractCssFromSource(code) {
 	return embeddedCodes;
 }
 /**
+* Build an embedded virtual code from a single mapping produced by the compiler
+* (`cssMappings` / `scriptMappings`). The embedded document text is the region's
+* `customData.content`; `languageId` selects which Volar service handles it
+* (`css`, `typescript`, or `javascript`).
+* @param {CodeMapping} mapping
+* @param {string} languageId
+* @returns {VirtualCode}
+*/
+function create_embedded_code_from_mapping(mapping, languageId) {
+	const content = mapping.data?.customData?.content ?? "";
+	return {
+		id: mapping.data?.customData?.embeddedId,
+		languageId,
+		snapshot: {
+			getText: (start, end) => content.substring(start, end),
+			getLength: () => mapping.lengths[0],
+			getChangeRange: () => void 0
+		},
+		mappings: [mapping],
+		embeddedCodes: []
+	};
+}
+/**
+* Extract raw script content from `<script>...<\/script>` tags in source code, used
+* as a fallback for script intellisense while the file has a fatal compile error
+* (no AST available — the normal path derives regions from the compiler's
+* `scriptMappings` instead). Parallels {@link extractCssFromSource}.
+* Every body is treated as TypeScript (a superset of JS), so the attributes are
+* never inspected. The opening-tag pattern refuses to match self-closing
+* `<script src=... />` tags (the `/` before `>` must not close the tag), so they
+* can't swallow a later real script's body.
+* @param {string} code - The source code to extract scripts from
+* @returns {VirtualCode[]} Array of embedded TypeScript virtual codes
+*/
+function extractScriptFromSource(code) {
+	/** @type {VirtualCode[]} */
+	const embeddedCodes = [];
+	const scriptRegex = /<script\b((?:[^>"'/]|"[^"]*"|'[^']*'|\/(?!>))*)>([\s\S]*?)<\/script>/gi;
+	let match;
+	let index = 0;
+	while ((match = scriptRegex.exec(code)) !== null) {
+		const attrs = match[1];
+		const scriptContent = match[2];
+		const scriptStart = match.index + (7 + attrs.length + 1);
+		const scriptLength = scriptContent.length;
+		const id = `script_${index}`;
+		log$9(`Extracted script region ${index}: offset ${scriptStart}, length ${scriptLength}`);
+		/** @type {CodeMapping} */
+		const mapping = {
+			sourceOffsets: [scriptStart],
+			generatedOffsets: [0],
+			lengths: [scriptLength],
+			generatedLengths: [scriptLength],
+			data: {
+				verification: true,
+				completion: true,
+				semantic: true,
+				navigation: true,
+				structure: true,
+				format: false,
+				customData: {
+					content: scriptContent,
+					embeddedId: id
+				}
+			}
+		};
+		embeddedCodes.push(create_embedded_code_from_mapping(mapping, "typescript"));
+		index++;
+	}
+	if (embeddedCodes.length > 0) log$9(`Extracted ${embeddedCodes.length} script embedded codes from script tags`);
+	return embeddedCodes;
+}
+/**
 * Insert a typed dot back into the transpiled code and update mappings so the
 * source and generated offsets stay aligned for completion requests.
 * @param {VolarMappingsResult} transpiled
@@ -22610,4 +22698,4 @@ Object.defineProperty(exports, 'createRippleLanguageServer', {
     return createRippleLanguageServer;
   }
 });
-//# sourceMappingURL=server-D9tbDqrh.js.map
+//# sourceMappingURL=server-DhFWQsiH.js.map