@tamagui/language-service 3.0.0-beta.1216.1 → 3.0.0-beta.1309.1

package/README.md

@@ -1,140 +1,31 @@
 # `@tamagui/language-service`
 
-TypeScript language-service completions for Tamagui flat style values. The
-plugin reads the `.tamagui/tamagui.config.json` file emitted from the active
-Tamagui runtime config, then delegates its vocabulary, parsing, and
-property-family validation to `@tamagui/style-grammar`.
-
-```json
-{
-  "compilerOptions": {
-    "plugins": [{ "name": "@tamagui/language-service" }]
-  }
-}
-```
-
-VS Code must also be able to resolve the plugin package. Select the workspace
-TypeScript version, or add this machine setting and restart the TypeScript
-server:
-
-```json
-{
-  "js/ts.tsserver.pluginPaths": ["node_modules"]
-}
+Shared flat-value tooling for editors, ESLint, and `tamagui check`.
+
+The package reads the `.tamagui/tamagui.config.json` artifact emitted by the
+compiler. Its entry points project the same grammar into completion,
+diagnostic, hover, color, and project-checking APIs:
+
+| entry | purpose |
+| --- | --- |
+| `@tamagui/language-service` | browser-safe core, document, and extractor APIs |
+| `@tamagui/language-service/core` | tooling for one property and value |
+| `@tamagui/language-service/document` | tooling mapped to source offsets |
+| `@tamagui/language-service/extract-sucrase` | token-stream JSX extraction |
+| `@tamagui/language-service/extract-estree` | ESTree JSX extraction |
+| `@tamagui/language-service/check` | Node project checker used by `tamagui check` |
+
+Editor integration is owned by the standalone Rust language server in
+`@tamagui/lsp`. It speaks standard LSP and does not load TypeScript or install a
+tsserver plugin. The VS Code extension is a thin client for the same binary used
+by other editors.
+
+```bash
+npm install --save-dev @tamagui/lsp
 ```
 
-`js/ts.tsserver.pluginPaths` is machine-scoped, so VS Code ignores it in a
-workspace `.vscode/settings.json` file.
-
-VS Code also disables automatic suggestions inside strings by default. Enable
-them for TSX if completion should open after typing a space in a value:
+For CI and pre-commit checks:
 
-```json
-{
-  "[typescriptreact]": {
-    "editor.quickSuggestions": {
-      "strings": "on"
-    }
-  }
-}
+```bash
+tamagui check
 ```
-
-VS Code's TypeScript provider does not register `:` as a completion trigger.
-The companion Tamagui Language Service extension retriggers suggestions after a
-modifier colon and delegates the resulting request back to this plugin.
-
-If the generated config lives elsewhere, set `configPath` relative to the
-TypeScript project:
-
-```json
-{
-  "compilerOptions": {
-    "plugins": [
-      {
-        "name": "@tamagui/language-service",
-        "configPath": ".tamagui/tamagui.config.json"
-      }
-    ]
-  }
-}
-```
-
-The plugin completes configured values and modifiers in base values and
-conditional clause payloads on components carrying Tamagui's `staticConfig`
-type marker and configurations passed to the core Tamagui `styled()` export.
-TypeScript's contextual prop type remains the authority for whether the host
-accepts that property and value.
-
-Modifier suggestions are sorted as state, group, media, container, root theme,
-then platform. `hover:` and `press:` lead the state group. Nested themes remain
-valid `<Theme>` targets but are not flat-value modifiers, so an active
-`dark_blue` theme matches `dark:` and never adds a `dark_blue:` suggestion.
-After a modifier colon, the plugin offers both property values and another
-modifier, so `margin="4 sm:h"` completes to `margin="4 sm:hover:"`.
-State continuations such as `hover:` and `press:` sort first, followed by the
-other modifier categories and configured property values. A finished chain such
-as `margin="4 web:sm:hover:"` still includes its payload tokens in that list.
-Modifier completion traverses a trie derived from the generated config. The
-canonical authoring order is platform, root theme, container, viewport media,
-group state, then subject state. A trie node omits conditions already used,
-aliases of used conditions, additional platforms or root themes, earlier
-categories, and conditions beyond the emitter's five non-platform limit.
-Each category occupies one slot in a clause. For example, `hover:` offers
-payload values and never another subject state such as `press:`, while `sm:`
-never offers another viewport-media modifier.
-Runtime parsing remains order-insensitive for compatibility, but tooling only
-authors the canonical shape. A completed payload resets traversal, so every new
-space-delimited clause starts from the trie root at arbitrary program length.
-
-Container conditions include their size: `@sm:` targets the nearest container
-and `@sm/layout:` targets a named container. `@container:` is not a modifier.
-
-It does not carry a fallback vocabulary. A missing or invalid generated config
-produces no Tamagui completions, so the editor cannot suggest names the runtime
-config does not define. The generated config is watched and its vocabulary is
-reloaded without restarting tsserver.
-
-## Package layout: one engine, many hosts
-
-`@tamagui/style-grammar` owns what every value MEANS. This package projects
-that engine into editor- and checker-shaped results, and each host stays a
-thin adapter:
-
-| entry | runs in | provides |
-| --- | --- | --- |
-| `@tamagui/language-service` | tsserver | completions, diagnostics, hover (quick info) |
-| `@tamagui/language-service/core` | anywhere (browser-safe) | `createStyleTooling(configJson)`: completions, diagnostics, annotations, hover, color swatches for one prop/value |
-| `@tamagui/language-service/document` | anywhere (browser-safe) | `createDocumentStyleTooling(tooling, extract)`: the same, mapped to file offsets |
-| `@tamagui/language-service/extract-sucrase` | anywhere (browser-safe) | token-stream site extraction; inject your own sucrase `parse`/`TokenType` so bundles never duplicate it |
-| `@tamagui/language-service/extract-estree` | anywhere | the same site contract from any ESTree program (eslint, oxc-parser) |
-| `@tamagui/language-service/check` | node | `checkStyleFiles` + `formatCheckResults`, the engine behind `tamagui check` |
-
-Every path takes the same input: the `.tamagui/tamagui.config.json` artifact
-the compiler emits. `core`, `document`, and `extract-sucrase` have no node,
-typescript, or sucrase imports — bundled together they are ~15KB gzipped — so
-an in-browser IDE embeds them directly:
-
-```ts
-import { createStyleTooling } from '@tamagui/language-service/core'
-import { createDocumentStyleTooling } from '@tamagui/language-service/document'
-import { createSucraseStyleSiteExtractor } from '@tamagui/language-service/extract-sucrase'
-import { parse } from 'sucrase/dist/parser/index.js'
-import { TokenType } from 'sucrase/dist/parser/tokenizer/types.js'
-
-const tooling = createStyleTooling(configJson)
-const document = createDocumentStyleTooling(
-  tooling,
-  createSucraseStyleSiteExtractor({ parse, TokenType }, {
-    isStyleProp: (name) => tooling.isStyleProp(name),
-  })
-)
-document.completionsAt(source, offset)
-document.diagnostics(source)
-document.hoverAt(source, offset)
-document.colors(source)
-```
-
-The VS Code extension (`code/core/language-service-vscode`) contributes this
-plugin through `typescriptServerPlugins` (zero per-project tsconfig setup),
-adds inline color swatches through the document API, and retriggers
-completions after modifier colons.

package/dist/cjs/index.cjs

@@ -2,12 +2,6 @@ var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-	for (var name in all) __defProp(target, name, {
-		get: all[name],
-		enumerable: true
-	});
-};
 var __copyProps = (to, from, except, desc) => {
 	if (from && typeof from === "object" || typeof from === "function") {
 		for (let key of __getOwnPropNames(from)) if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
@@ -17,284 +11,11 @@ var __copyProps = (to, from, except, desc) => {
 	}
 	return to;
 };
+var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var index_exports = {};
-__export(index_exports, { default: () => index_default });
 module.exports = __toCommonJS(index_exports);
-var import_node_path = require("node:path");
-var import_core = require("./core.cjs");
-var import_host = require("./host.cjs");
-const completionSource = "@tamagui/language-service";
-const diagnosticCode = 78711;
-const defaultConfigPath = ".tamagui/tamagui.config.json";
-const flatStyledModules = /* @__PURE__ */ new Set([
-	"tamagui",
-	"tamagui/unstyled",
-	"@tamagui/core",
-	"@tamagui/ui",
-	"@tamagui/web"
-]);
-function loadTooling(info, configPath) {
-	const contents = info.serverHost.readFile(configPath);
-	if (contents === void 0) return null;
-	try {
-		return (0, import_core.createStyleTooling)(JSON.parse(contents));
-	} catch {
-		return null;
-	}
-}
-function findStringLiteralAtPosition(typescript, sourceFile, position) {
-	let found = null;
-	const visit = (node) => {
-		if (position < node.getFullStart() || position > node.getEnd()) return;
-		if (typescript.isStringLiteralLike(node) && position >= node.getStart(sourceFile) + 1 && position <= node.getEnd() - 1) {
-			found = node;
-			return;
-		}
-		typescript.forEachChild(node, visit);
-	};
-	visit(sourceFile);
-	return found;
-}
-function importedBindings(typescript, sourceFile) {
-	const styled = /* @__PURE__ */ new Set();
-	for (const statement of sourceFile.statements) {
-		if (!typescript.isImportDeclaration(statement) || !typescript.isStringLiteral(statement.moduleSpecifier)) {
-			continue;
-		}
-		const source = statement.moduleSpecifier.text;
-		if (!flatStyledModules.has(source)) continue;
-		const bindings = statement.importClause?.namedBindings;
-		if (!bindings) continue;
-		if (typescript.isNamespaceImport(bindings)) continue;
-		for (const element of bindings.elements) {
-			const imported = element.propertyName?.text || element.name.text;
-			if (imported === "styled") styled.add(element.name.text);
-		}
-	}
-	return { styled };
-}
-function propertyName(typescript, name) {
-	if (typescript.isIdentifier(name) || typescript.isStringLiteral(name)) {
-		return name.text;
-	}
-	return null;
-}
-function completionProperty(typescript, literal, tooling, checker, bindings) {
-	let parent = literal.parent;
-	if (typescript.isJsxExpression(parent)) parent = parent.parent;
-	if (typescript.isJsxAttribute(parent)) {
-		if (!typescript.isIdentifier(parent.name)) return null;
-		const property2 = parent.name.text;
-		if (!tooling.styleProps.has(property2)) return null;
-		const opening = parent.parent.parent;
-		if (!typescript.isJsxOpeningLikeElement(opening)) return null;
-		const host2 = (0, import_host.resolveTamaguiHost)(checker, opening.tagName);
-		if (!host2?.accepts(property2)) return null;
-		return { property: property2 };
-	}
-	if (!typescript.isPropertyAssignment(parent)) return null;
-	const property = propertyName(typescript, parent.name);
-	if (!property || !tooling.styleProps.has(property)) return null;
-	let current = parent;
-	while (current.parent && !typescript.isCallExpression(current.parent)) {
-		current = current.parent;
-	}
-	if (!current.parent || !typescript.isCallExpression(current.parent)) return null;
-	const call = current.parent;
-	if (call.arguments[1] !== current || !typescript.isIdentifier(call.expression) || !bindings.styled.has(call.expression.text)) {
-		return null;
-	}
-	const component = call.arguments[0];
-	const host = component && (0, import_host.resolveTamaguiHost)(checker, component);
-	if (!host?.accepts(property)) return null;
-	return { property };
-}
-function siteForLiteral(typescript, sourceFile, literal, tooling, checker, bindings) {
-	const site = completionProperty(typescript, literal, tooling, checker, bindings);
-	if (!site) return null;
-	const contentStart = literal.getStart(sourceFile) + 1;
-	const contentEnd = literal.getEnd() - 1;
-	const sourceInput = sourceFile.text.slice(contentStart, contentEnd);
-	if (literal.text !== sourceInput) return null;
-	return {
-		property: site.property,
-		value: literal.text,
-		contentStart,
-		literal
-	};
-}
-function collectLiteralSites(typescript, sourceFile, tooling, checker, bindings) {
-	const sites = [];
-	const visit = (node) => {
-		if (typescript.isStringLiteralLike(node)) {
-			const site = siteForLiteral(typescript, sourceFile, node, tooling, checker, bindings);
-			if (site) sites.push(site);
-			return;
-		}
-		typescript.forEachChild(node, visit);
-	};
-	visit(sourceFile);
-	return sites;
-}
-function copyLanguageService(service) {
-	const proxy = /* @__PURE__ */ Object.create(null);
-	for (const key of Object.keys(service)) {
-		const value = service[key];
-		proxy[key] = typeof value === "function" ? value.bind(service) : value;
-	}
-	return proxy;
-}
-const init = ({ typescript }) => ({ create(info) {
-	const pluginConfig = info.config;
-	const configuredPath = pluginConfig?.configPath || defaultConfigPath;
-	const configPath = (0, import_node_path.isAbsolute)(configuredPath) ? configuredPath : (0, import_node_path.resolve)(info.project.getCurrentDirectory(), configuredPath);
-	let tooling = loadTooling(info, configPath);
-	const watcher = info.serverHost.watchFile(configPath, () => {
-		tooling = loadTooling(info, configPath);
-	});
-	const proxy = copyLanguageService(info.languageService);
-	const baseCompletions = info.languageService.getCompletionsAtPosition.bind(info.languageService);
-	const baseDetails = info.languageService.getCompletionEntryDetails.bind(info.languageService);
-	const baseSemanticDiagnostics = info.languageService.getSemanticDiagnostics.bind(info.languageService);
-	const baseQuickInfo = info.languageService.getQuickInfoAtPosition.bind(info.languageService);
-	const baseDispose = info.languageService.dispose.bind(info.languageService);
-	const bindingsBySourceFile = /* @__PURE__ */ new WeakMap();
-	const fileContext = (fileName) => {
-		const program = info.languageService.getProgram();
-		const sourceFile = program?.getSourceFile(fileName);
-		if (!program || !sourceFile) return null;
-		let bindings = bindingsBySourceFile.get(sourceFile);
-		if (!bindings) {
-			bindings = importedBindings(typescript, sourceFile);
-			bindingsBySourceFile.set(sourceFile, bindings);
-		}
-		return {
-			sourceFile,
-			checker: program.getTypeChecker(),
-			bindings
-		};
-	};
-	proxy.getCompletionsAtPosition = (fileName, position, options, formattingSettings) => {
-		const getBaseCompletions = () => baseCompletions(fileName, position, options, formattingSettings);
-		if (!tooling) return getBaseCompletions();
-		const context = fileContext(fileName);
-		if (!context) return getBaseCompletions();
-		const { sourceFile, checker, bindings } = context;
-		const literal = findStringLiteralAtPosition(typescript, sourceFile, position);
-		if (!literal) return getBaseCompletions();
-		const site = siteForLiteral(typescript, sourceFile, literal, tooling, checker, bindings);
-		if (!site) return getBaseCompletions();
-		const cursorCompletions = tooling.completions(site.property, site.value, position - site.contentStart);
-		if (!cursorCompletions) return getBaseCompletions();
-		const replacementSpan = {
-			start: site.contentStart + cursorCompletions.replaceStart,
-			length: cursorCompletions.replaceLength
-		};
-		const entries = [];
-		let contextualType;
-		for (const completion of cursorCompletions.completions) {
-			const insertText = completion.insertText || completion.value;
-			const modifierKind = completion.kind === "modifier" ? tooling.modifierKind(completion.value) : void 0;
-			if (completion.kind === "keyword") {
-				contextualType ||= checker.getContextualType(literal);
-				if (!contextualType || !checker.isTypeAssignableTo(checker.getStringLiteralType(insertText), contextualType)) {
-					continue;
-				}
-			}
-			entries.push({
-				name: completion.value,
-				kind: typescript.ScriptElementKind.string,
-				kindModifiers: "",
-				sortText: (0, import_core.completionSortText)(completion, modifierKind),
-				insertText,
-				replacementSpan,
-				source: completionSource,
-				labelDetails: { description: modifierKind ? `Tamagui ${modifierKind} modifier` : completion.kind === "configured" ? "Tamagui configured value" : "Tamagui style keyword" }
-			});
-		}
-		if (entries.length === 0) return getBaseCompletions();
-		return {
-			isGlobalCompletion: false,
-			isMemberCompletion: false,
-			isNewIdentifierLocation: true,
-			isIncomplete: true,
-			entries
-		};
-	};
-	proxy.getCompletionEntryDetails = (fileName, position, entryName, formatOptions, source, preferences, data) => {
-		if (source === completionSource) {
-			return {
-				name: entryName,
-				kind: typescript.ScriptElementKind.string,
-				kindModifiers: "",
-				displayParts: [{
-					text: entryName,
-					kind: "stringLiteral"
-				}],
-				documentation: [{
-					text: "Resolved from the active Tamagui config.",
-					kind: "text"
-				}],
-				tags: []
-			};
-		}
-		return baseDetails(fileName, position, entryName, formatOptions, source, preferences, data);
-	};
-	proxy.getSemanticDiagnostics = (fileName) => {
-		const diagnostics = [...baseSemanticDiagnostics(fileName)];
-		if (!tooling) return diagnostics;
-		const context = fileContext(fileName);
-		if (!context) return diagnostics;
-		const { sourceFile, checker, bindings } = context;
-		for (const site of collectLiteralSites(typescript, sourceFile, tooling, checker, bindings)) {
-			for (const diagnostic of tooling.diagnostics(site.property, site.value)) {
-				diagnostics.push({
-					file: sourceFile,
-					start: site.contentStart + diagnostic.start,
-					length: Math.max(1, diagnostic.end - diagnostic.start),
-					messageText: diagnostic.message,
-					category: typescript.DiagnosticCategory.Error,
-					code: diagnosticCode,
-					source: completionSource
-				});
-			}
-		}
-		return diagnostics;
-	};
-	proxy.getQuickInfoAtPosition = (fileName, position) => {
-		const getBaseQuickInfo = () => baseQuickInfo(fileName, position);
-		if (!tooling) return getBaseQuickInfo();
-		const context = fileContext(fileName);
-		if (!context) return getBaseQuickInfo();
-		const { sourceFile, checker, bindings } = context;
-		const literal = findStringLiteralAtPosition(typescript, sourceFile, position);
-		if (!literal) return getBaseQuickInfo();
-		const site = siteForLiteral(typescript, sourceFile, literal, tooling, checker, bindings);
-		if (!site) return getBaseQuickInfo();
-		const hover = tooling.hover(site.property, site.value, position - site.contentStart);
-		if (!hover) return getBaseQuickInfo();
-		return {
-			kind: typescript.ScriptElementKind.string,
-			kindModifiers: "",
-			textSpan: {
-				start: site.contentStart + hover.start,
-				length: hover.end - hover.start
-			},
-			displayParts: [{
-				text: hover.text,
-				kind: "stringLiteral"
-			}],
-			documentation: [{
-				text: hover.markdown,
-				kind: "text"
-			}]
-		};
-	};
-	proxy.dispose = () => {
-		watcher.close();
-		baseDispose();
-	};
-	return proxy;
-} });
-var index_default = init;
+__reExport(index_exports, require("./core.cjs"), module.exports);
+__reExport(index_exports, require("./document.cjs"), module.exports);
+__reExport(index_exports, require("./extract-estree.cjs"), module.exports);
+__reExport(index_exports, require("./extract-sucrase.cjs"), module.exports);