@tsrx/language-server 0.3.131 → 0.3.133

package/dist/language-server.js

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

package/dist/{server-BZ2bdQ1a.js → server-iYrbcyFX.js}

@@ -1699,21 +1699,33 @@ function logTSRXErrors(file_name, errors) {
 	}
 }
 /**
-* Extract CSS content from <style>...</style> tags in source code
+* Extract raw CSS content from `<style>...</style>` tags in source code, used as a
+* fallback for CSS intellisense while the file has a fatal compile error (no AST
+* available — the normal path derives regions from the compiler's `cssMappings`
+* instead). Parallels {@link extractScriptFromSource}.
+* The opening-tag pattern is attribute-aware: a `>` inside a quoted value or an
+* `{...}` expression container (one level of nesting) does not end the tag, so
+* `apply={cond ? a : b}` and `apply={(x) => y}` are handled. It refuses to match
+* self-closing `<style apply={theme} />` blocks (the `/` before `>` must not close
+* the tag): they carry no CSS body, so — like the compiler's `cssMappings` — they
+* yield no region and can't swallow a later bodied block. One region is produced
+* per bodied block, in source order, whether the blocks share a scope or sit in
+* nested `@{ ... }` / control-flow bodies.
 * @param {string} code - The source code to extract CSS from
 * @returns {VirtualCode[]} Array of embedded CSS virtual codes
 */
 function extractCssFromSource(code) {
 	/** @type {VirtualCode[]} */
 	const embeddedCodes = [];
-	const styleRegex = /<style\b[^>]*>([\s\S]*?)<\/style>/gi;
+	const styleRegex = /<style\b((?:[^>"'{}/]|"[^"]*"|'[^']*'|\{(?:[^{}]|\{[^{}]*\})*\}|\/(?!>))*)>([\s\S]*?)<\/style>/gi;
 	let match;
 	let index = 0;
 	while ((match = styleRegex.exec(code)) !== null) {
-		const fullMatch = match[0];
-		const cssContent = match[1];
-		const cssStart = match.index + (fullMatch.indexOf(">") + 1);
+		const attrs = match[1];
+		const cssContent = match[2];
+		const cssStart = match.index + (6 + attrs.length + 1);
 		const cssLength = cssContent.length;
+		const id = `style_${index}`;
 		log$9(`Extracted CSS region ${index}: offset ${cssStart}, length ${cssLength}`);
 		/** @type {CodeMapping} */
 		const mapping = {
@@ -1730,21 +1742,11 @@ function extractCssFromSource(code) {
 				format: false,
 				customData: {
 					content: cssContent,
-					embeddedId: `style_${index}`
+					embeddedId: id
 				}
 			}
 		};
-		embeddedCodes.push({
-			id: `style_${index}`,
-			languageId: "css",
-			snapshot: {
-				getText: (start, end) => cssContent.substring(start, end),
-				getLength: () => cssLength,
-				getChangeRange: () => void 0
-			},
-			mappings: [mapping],
-			embeddedCodes: []
-		});
+		embeddedCodes.push(create_embedded_code_from_mapping(mapping, "css"));
 		index++;
 	}
 	if (embeddedCodes.length > 0) log$9(`Extracted ${embeddedCodes.length} CSS embedded codes from style tags`);
@@ -21589,7 +21591,7 @@ function parseCompilationErrorWithDocument(error, virtualCode, sourceMap, docume
 		},
 		message: error.message,
 		source: "TSRX",
-		code: "tsrx-usage-error"
+		code: error.code ?? "tsrx-usage-error"
 	};
 }
 /**
@@ -22190,6 +22192,31 @@ const TSRX_SNIPPETS = [
 	}
 ];
 /**
+* Target-neutral `<style>` block snippets. Scoped `<style>` blocks, `$class`, and `apply` are
+* shared TSRX syntax lowered by every target, so these are offered in every `.tsrx` file. They
+* live outside `TSRX_SNIPPETS` because they are not `@`-directives: they are offered when the
+* user types `<` (or `<sty…`) in a template, anchored at the `<` like the `@` path anchors at `@`.
+*/
+const STYLE_SNIPPETS = [{
+	label: "<style>",
+	filterText: "style",
+	kind: import_language_server.CompletionItemKind.Snippet,
+	detail: "Scoped style block",
+	documentation: "A sibling-scoped `<style>` block: a child of an element or fragment that styles its siblings and everything below them, never the element that contains it; sibling blocks share one hash (in a `@{ … }` or control-flow body, wrap it with its output in a fragment). Raw CSS here is TSRX template syntax, so it needs an enclosing `@{ … }` or control-flow body. Assign it (`const theme = <style>…</style>`) to reuse its classes as `theme.card` and apply it elsewhere with `<style apply={theme} />`.",
+	insertText: "<style>\n	$0\n</style>",
+	insertTextFormat: import_language_server.InsertTextFormat.Snippet,
+	sortText: "0-style"
+}, {
+	label: "<style apply={…} />",
+	filterText: "style apply",
+	kind: import_language_server.CompletionItemKind.Snippet,
+	detail: "Apply an assigned style block",
+	documentation: "Stamp the classes of an assigned `<style>` block onto the items beside this block and everything below them. `apply` takes a style block (`{theme}`) or an array of them (`{[base, theme]}`); a self-closing block has no CSS of its own.",
+	insertText: "<style apply={${1:theme}} />",
+	insertTextFormat: import_language_server.InsertTextFormat.Snippet,
+	sortText: "0-style-apply"
+}];
+/**
 * Ripple-runtime-only snippets: reactivity primitives (`track`/`effect`/`untrack`)
 * and server modules. These reference the `ripple` runtime API, so they are only
 * offered when the file is compiled by the Ripple target (see `is_ripple_target_file`).
@@ -22282,6 +22309,20 @@ const RIPPLE_IMPORTS = [
 	}
 ];
 /**
+* Whether the line before the cursor ends in a `<` that starts a tag (`<`, `<sty`) rather than a
+* comparison operator (`a <`, `if (x <`). A tag `<` is at the start of the line or follows
+* punctuation that cannot end an operand (`>`, `{`, `(`, `,`, `;`, `=`, `?`, `:`, `&`, `|`, `!`,
+* `[`) or an expression keyword (`return <`).
+* @param {string} line - Line text up to the cursor
+* @returns {boolean}
+*/
+function isTagStart(line) {
+	const match = line.match(/<(\w*)$/);
+	if (!match) return false;
+	const before = line.slice(0, match.index).trimEnd();
+	return before === "" || /[>{(,;=?:&|!\[]$/.test(before) || /\b(?:return|yield|await|case|else|do|in|of|typeof|void)$/.test(before);
+}
+/**
 * @returns {LanguageServicePlugin}
 */
 function createCompletionPlugin() {
@@ -22371,6 +22412,25 @@ function createCompletionPlugin() {
 							isIncomplete: false
 						};
 					}
+					const tagStartMatch = isTagStart(line) ? line.match(/<(\w*)$/) : null;
+					if (tagStartMatch) {
+						const typed = `<${tagStartMatch[1]}`;
+						const replaceRange = {
+							start: {
+								line: position.line,
+								character: position.character - typed.length
+							},
+							end: position
+						};
+						for (const snippet of STYLE_SNIPPETS) items.push({
+							...snippet,
+							filterText: `<${snippet.filterText}`,
+							textEdit: {
+								range: replaceRange,
+								newText: snippet.insertText
+							}
+						});
+					}
 					const trackedMatch = is_ripple && line.match(/(new\s+)?[R,M]([\w\.]*)$/);
 					if (trackedMatch) {
 						const hasNew = !!trackedMatch[1];
@@ -22406,6 +22466,7 @@ function createCompletionPlugin() {
 					const wordMatch = line.match(/(\w+)$/);
 					log$5("Current word:", wordMatch ? wordMatch[1] : "");
 					items.push(COMPONENT_SNIPPET, ...TSRX_SNIPPETS);
+					if (!tagStartMatch) items.push(...STYLE_SNIPPETS);
 					if (is_ripple) items.push(...RIPPLE_API_SNIPPETS);
 					return {
 						items,
@@ -22476,63 +22537,94 @@ async provideAutoInsertSnippet(document, position, lastChange, _token) {
 					return null;
 				}
 				const offset = document.offsetAt(position);
-				const mapping = virtualCode.findMappingByGeneratedRange(lastChange.rangeOffset, offset);
-				if (!mapping) return null;
-				const sourceOffset = mapping.sourceOffsets[0];
+				const mapping = virtualCode.findMappingByGeneratedRange(offset - 1, offset);
+				/** @type {number} */
+				let sourceOffset;
+				/** @type {boolean} */
+				let isFallback = false;
+				if (mapping) sourceOffset = mapping.sourceOffsets[0];
+				else if (virtualCode.fatalErrors.length > 0 && virtualCode.generatedCode === virtualCode.originalCode) {
+					sourceOffset = offset - 1;
+					isFallback = true;
+				} else return null;
 				const sourceCode = virtualCode.originalCode;
 				if (sourceCode[sourceOffset - 1] === "/") return null;
+				/** @type {string | null} */
+				let tagName = null;
+				/** @type {string} */
+				let line = "";
 				let attempts = 0;
-				let found = false;
-				let i = sourceOffset - 1;
-				for (; i >= 0; i--) {
-					if (sourceCode[i] === "<") {
-						attempts++;
-						if (virtualCode.findMappingBySourceRange(i, i + 1)) {
-							found = true;
-							break;
-						}
+				for (let i = sourceOffset - 1; i >= 0 && attempts < 3; i--) {
+					if (sourceCode[i] !== "<") continue;
+					attempts++;
+					line = sourceCode.slice(i, sourceOffset + 1);
+					const candidate = matchOpeningTag(line);
+					if (!candidate) continue;
+					if (isFallback || virtualCode.findMappingBySourceRange(i, i + 1) || virtualCode.findMappingBySourceRange(i + 1, i + 1 + candidate.length)) {
+						tagName = candidate;
+						break;
 					}
-					if (attempts === 3) break;
-				}
-				if (!found) {
-					log$4(`No opening tag position found from source position ${sourceOffset}`);
-					return null;
 				}
-				const line = sourceCode.slice(i, sourceOffset + 1);
 				log$4("Auto-insert triggered at:", {
 					selection: `${position.line}:${position.character}`,
 					line,
 					change: lastChange,
-					sourceOffset
+					sourceOffset,
+					isFallback
 				});
-				const tagMatch = line.match(/<([@$\w][\w.-]*)[^>]*?(?<!\/)>$/);
-				if (!tagMatch) {
+				if (!tagName) {
 					log$4("No tag match found");
 					return null;
 				}
-				const tagName = tagMatch[1];
 				log$4("Tag matched:", tagName);
 				if (VOID_ELEMENTS.has(tagName.toLowerCase())) {
 					log$4("Void element, skipping auto-close:", tagName);
 					return null;
 				}
-				if (document.getText({
-					start: position,
-					end: {
-						line: position.line,
-						character: position.character + 100
-					}
-				}).startsWith(`</${tagName}>`)) {
+				const closingTag = `</${tagName}>`;
+				if (sourceCode.startsWith(closingTag, sourceOffset + 1)) {
 					log$4("Closing tag already exists, skipping");
 					return null;
 				}
-				const closingTag = `</${tagName}>`;
 				log$4("Inserting closing tag:", closingTag);
 				return `$0${closingTag}`;
 			} };
 		}
 	};
 }
+/**
+* Match an opening tag `<name …>` that ends exactly at the end of `text` and return its name.
+*
+* Attribute expressions may themselves contain `>` (`<style apply={x > y ? a : b}>`,
+* `<div hidden={a > b}>`) and quoted values may contain anything, so the attribute region is
+* walked with brace depth and quote tracking instead of a `[^>]*` regex. Returns null when
+* `text` is not a single opening tag: the trailing `>` sits inside `{…}` (the user is typing an
+* expression, not closing the tag), an earlier `>` already closed the tag, or the tag is
+* self-closing (`<style apply={theme} />`).
+*
+* @param {string} text - Source text from the tag's `<` up to and including the typed `>`
+* @returns {string | null}
+*/
+function matchOpeningTag(text) {
+	const nameMatch = text.match(/^<([@$\w][\w.-]*)/);
+	if (!nameMatch) return null;
+	let depth = 0;
+	/** @type {string | null} */
+	let quote = null;
+	for (let i = nameMatch[0].length; i < text.length; i++) {
+		const char = text[i];
+		if (quote) {
+			if (char === "\\" && depth > 0) i++;
+			else if (char === quote) quote = null;
+			continue;
+		}
+		if (char === "\"" || char === "'" || depth > 0 && char === "`") quote = char;
+		else if (char === "{") depth++;
+		else if (char === "}") depth = Math.max(0, depth - 1);
+		else if (char === ">" && depth === 0) return i === text.length - 1 && text[i - 1] !== "/" ? nameMatch[1] : null;
+	}
+	return null;
+}
 
 //#endregion
 //#region src/typescriptDiagnosticPlugin.js
@@ -23470,4 +23562,4 @@ Object.defineProperty(exports, 'createTsrxLanguageServer', {
     return createTsrxLanguageServer;
   }
 });
-//# sourceMappingURL=server-BZ2bdQ1a.js.map
+//# sourceMappingURL=server-iYrbcyFX.js.map