@tamagui/language-service 0.0.0-bootstrap.0 → 3.0.0-beta.643.1

package/dist/cjs/index.cjs

@@ -0,0 +1,301 @@
+
+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, {
+			get: () => from[key],
+			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+		});
+	}
+	return to;
+};
+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;