@ts-for-gir/language-server 0.1.0

package/README.md

@@ -0,0 +1,257 @@
+# @ts-for-gir/language-server
+
+A TypeScript validation and hover utility for testing generated GIR type definitions.
+
+## Features
+
+- TypeScript code validation optimized for GJS/GIR types
+- Essential compiler error detection
+- Support for GIR type definitions and module resolution
+- **Hover functionality** for type inspection at specific positions
+- Automatic type discovery for GIR definitions
+- Clean API for validation and type checking
+
+## Installation
+
+```bash
+yarn add @ts-for-gir/language-server
+```
+
+## Usage
+
+### Basic TypeScript Validation
+
+```typescript
+import { validateTypeScript } from '@ts-for-gir/language-server';
+
+const result = validateTypeScript(`
+  interface Test {
+    name: string;
+  }
+  const obj: Test = { name: "test" };
+`);
+
+console.log(result.success); // true or false
+console.log(result.errors);  // Array of error messages
+```
+
+### GIR Type Validation
+
+```typescript
+import { validateGIRTypeScript } from '@ts-for-gir/language-server';
+import path from 'path';
+
+const typesPath = path.resolve('./types/@types');
+const result = validateGIRTypeScript(`
+  import Gtk from 'gi://Gtk?version=4.0';
+  
+  const button = new Gtk.Button();
+  button.set_label("Hello World");
+`, typesPath);
+
+console.log(result.success); // true or false
+console.log(result.errors);  // Array of error messages
+```
+
+### Automatic GIR Type Discovery
+
+```typescript
+import { validateGIRTypeScriptAuto } from '@ts-for-gir/language-server';
+
+const result = validateGIRTypeScriptAuto(`
+  import Gtk from 'gi://Gtk?version=4.0';
+  
+  const button = new Gtk.Button();
+  button.set_label("Hello World");
+`);
+
+console.log(result.success); // true or false
+```
+
+### Hover Functionality - Type Inspection
+
+```typescript
+import { getIdentifierTypeAuto } from '@ts-for-gir/language-server';
+
+const code = `
+  import Gtk from 'gi://Gtk?version=4.0';
+  
+  const button = new Gtk.Button();
+  const window = new Gtk.Window();
+`;
+
+// Get type information for the 'button' variable
+const result = getIdentifierTypeAuto(code, 'button');
+
+console.log(result.success); // true or false
+console.log(result.type);    // e.g., "Gtk.Button"
+console.log(result.documentation); // JSDoc documentation if available
+```
+
+### Type Expectation - Validate Expected Types
+
+```typescript
+import { expectIdentifierTypeAuto } from '@ts-for-gir/language-server';
+
+const code = `
+  import Gtk from 'gi://Gtk?version=4.0';
+  
+  const button = new Gtk.Button();
+  const window = new Gtk.Window();
+`;
+
+// Validate that 'button' is of type 'Gtk.Button' (exact match)
+const result = expectIdentifierTypeAuto(code, 'button', 'Gtk.Button');
+
+console.log(result.success);      // true or false
+console.log(result.matches);      // true if types match
+console.log(result.actualType);   // e.g., "Gtk.Button"
+console.log(result.expectedType); // "Gtk.Button"
+console.log(result.error);        // Error message if types don't match
+
+// Validate using RegExp pattern (flexible matching)
+const patternResult = expectIdentifierTypeAuto(code, 'button', /Button|Gtk\.Button/);
+console.log(patternResult.matches); // true if type matches pattern
+```
+
+## API
+
+### Validation Functions
+
+#### `validateTypeScript(code: string, options?: ValidationOptions)`
+
+Validates TypeScript code and returns validation results.
+
+**Returns:** `ValidationResult`
+- `success: boolean` - Whether validation passed
+- `errors: string[]` - Array of error messages
+- `warnings: string[]` - Array of warning messages
+
+**Options:**
+- `strict?: boolean` - Enable strict mode (default: true)
+- `typesPath?: string` - Path to directory containing GIR type definitions
+
+#### `validateGIRTypeScript(code: string, typesPath: string, options?: ValidationOptions)`
+
+Validates GIR TypeScript code with type definitions.
+
+#### `validateGIRTypeScriptAuto(code: string, options?: ValidationOptions)`
+
+Validates GIR TypeScript code with automatic type discovery.
+
+### Hover Functions
+
+#### `getIdentifierType(code: string, identifier: string, options?: HoverOptions)`
+
+Gets type information for a specific identifier in TypeScript code.
+
+**Returns:** `HoverResult`
+- `success: boolean` - Whether type checking succeeded
+- `type?: string` - The inferred type (e.g., "Gtk.Button", "string", "number")
+- `documentation?: string` - JSDoc documentation if available
+- `error?: string` - Error message if failed
+
+#### `getIdentifierTypeAuto(code: string, identifier: string, options?: HoverOptions)`
+
+Gets type information with automatic GIR type discovery.
+
+### Type Expectation Functions
+
+#### `expectIdentifierType(code: string, identifier: string, expectedType: string | RegExp, options?: HoverOptions)`
+
+Validates that a specific identifier has the expected type.
+
+**Returns:** `TypeExpectationResult`
+- `success: boolean` - Whether type checking succeeded
+- `matches: boolean` - Whether the actual type matches the expected type
+- `actualType?: string` - The actual inferred type
+- `expectedType: string | RegExp` - The expected type or pattern that was tested for
+- `documentation?: string` - JSDoc documentation if available
+- `error?: string` - Error message if validation failed
+
+**Expected Type Patterns:**
+- `string` - Exact type name match (e.g., "Gtk.Button")
+- `RegExp` - Pattern matching (e.g., `/Variant.*\[\]|Array.*Variant/`)
+
+#### `expectIdentifierTypeAuto(code: string, identifier: string, expectedType: string | RegExp, options?: HoverOptions)`
+
+Validates that a specific identifier has the expected type with automatic GIR type discovery.
+
+## Use Cases
+
+### Testing GIR Type Definitions
+
+```typescript
+import { expectIdentifierTypeAuto } from '@ts-for-gir/language-server';
+
+// Test if Gtk.Button type is correctly inferred
+const result = expectIdentifierTypeAuto(`
+  import Gtk from 'gi://Gtk?version=4.0';
+  const button = new Gtk.Button();
+`, 'button', 'Gtk.Button');
+
+// Should return: { success: true, matches: true, actualType: "Gtk.Button" }
+console.log(result.matches); // true if correctly typed
+```
+
+### Verifying Complex Type Inference
+
+```typescript
+// Test complex type inference
+const result = expectIdentifierTypeAuto(`
+  import Gtk from 'gi://Gtk?version=4.0';
+  
+  const box = new Gtk.Box(Gtk.Orientation.VERTICAL, 10);
+  const label = new Gtk.Label("Hello");
+  
+  box.append(label);
+`, 'box', 'Gtk.Box');
+
+// Verify the type is correctly inferred
+console.log(result.matches); // Should be true
+console.log(result.actualType); // Should be "Gtk.Box"
+```
+
+### Unit Testing Type Definitions
+
+```typescript
+import { expectIdentifierTypeAuto } from '@ts-for-gir/language-server';
+
+describe('GIR Type Tests', () => {
+  test('Gtk.Button should be correctly typed', () => {
+    const result = expectIdentifierTypeAuto(`
+      import Gtk from 'gi://Gtk?version=4.0';
+      const button = new Gtk.Button();
+    `, 'button', 'Gtk.Button');
+    
+    expect(result.success).toBe(true);
+    expect(result.matches).toBe(true);
+  });
+
+  test('GVariant unpack methods should return correct types', () => {
+    const result = expectIdentifierTypeAuto(`
+      import GLib from 'gi://GLib?version=2.0';
+      const variant = new GLib.Variant("as", ["one", "two"]);
+      const unpacked = variant.unpack();
+    `, 'unpacked', /Variant.*\[\]|Array.*Variant/);
+    
+    expect(result.success).toBe(true);
+    expect(result.matches).toBe(true);
+  });
+
+  test('Complex type patterns should work', () => {
+    const result = expectIdentifierTypeAuto(`
+      import GLib from 'gi://GLib?version=2.0';
+      const variant = new GLib.Variant("(si)", ["hello", 42]);
+      const deepUnpack = variant.deepUnpack();
+    `, 'deepUnpack', /\[string,\s*number\]/);
+    
+    expect(result.success).toBe(true);
+    expect(result.matches).toBe(true);
+  });
+});
+```
+
+## Development
+
+This package provides the foundation for building GIR type validation and inspection tools. The type expectation functionality enables precise testing of whether generated TypeScript definitions match the expected types, making it ideal for automated testing and validation of GIR type generation.

package/package.json

@@ -0,0 +1,35 @@
+{
+  "name": "@ts-for-gir/language-server",
+  "version": "0.1.0",
+  "description": "TypeScript Language Server utilities for validating generated GIR type definitions",
+  "type": "module",
+  "main": "src/index.ts",
+  "exports": {
+    ".": "./src/index.ts"
+  },
+  "keywords": [
+    "typescript",
+    "language-server",
+    "gir",
+    "gobject",
+    "introspection",
+    "validation"
+  ],
+  "author": "ts-for-gir contributors",
+  "license": "MIT",
+  "engines": {
+    "node": ">=22"
+  },
+  "dependencies": {
+    "@ts-for-gir/lib": "^4.0.0-beta.26",
+    "typescript": "^5.9.2"
+  },
+  "scripts": {
+    "test": "vitest run",
+    "test:watch": "vitest"
+  },
+  "devDependencies": {
+    "@types/node": "^24.2.1",
+    "vitest": "^3.2.4"
+  }
+}

package/src/__tests__/validation.test.ts

@@ -0,0 +1,192 @@
+/**
+ * Basic validation tests for language-server utilities
+ * Tests the core functionality of TypeScript validation and hover features
+ */
+
+import { describe, expect, it } from "vitest";
+import { expectIdentifierType, getIdentifierType, validateTypeScript } from "../index.ts";
+
+describe("Language Server Validation", () => {
+	describe("validateTypeScript", () => {
+		it("should validate correct TypeScript code", () => {
+			const code = `
+        interface User {
+          name: string;
+          age: number;
+        }
+        
+        const user: User = {
+          name: "John",
+          age: 30
+        };
+      `;
+
+			const result = validateTypeScript(code);
+			expect(result.success).toBe(true);
+			expect(result.errors).toHaveLength(0);
+		});
+
+		it("should detect type errors", () => {
+			const code = `
+        const num: number = "not a number";
+      `;
+
+			const result = validateTypeScript(code);
+			expect(result.success).toBe(false);
+			expect(result.errors.length).toBeGreaterThan(0);
+			expect(result.errors[0]).toContain("Type 'string' is not assignable to type 'number'");
+		});
+
+		it("should detect missing properties", () => {
+			const code = `
+        interface Config {
+          host: string;
+          port: number;
+        }
+        
+        const config: Config = {
+          host: "localhost"
+          // missing port
+        };
+      `;
+
+			const result = validateTypeScript(code);
+			expect(result.success).toBe(false);
+			expect(result.errors.length).toBeGreaterThan(0);
+		});
+	});
+
+	describe("getIdentifierType", () => {
+		it("should return type for simple variables", () => {
+			const code = `
+        const message: string = "Hello World";
+        const count: number = 42;
+        const isActive: boolean = true;
+      `;
+
+			const messageType = getIdentifierType(code, "message");
+			expect(messageType.success).toBe(true);
+			expect(messageType.type).toContain("string");
+
+			const countType = getIdentifierType(code, "count");
+			expect(countType.success).toBe(true);
+			expect(countType.type).toContain("number");
+
+			const activeType = getIdentifierType(code, "isActive");
+			expect(activeType.success).toBe(true);
+			expect(activeType.type).toContain("boolean");
+		});
+
+		it("should return type for interface instances", () => {
+			const code = `
+        interface Product {
+          id: string;
+          name: string;
+          price: number;
+        }
+        
+        const product: Product = {
+          id: "123",
+          name: "Laptop",
+          price: 999.99
+        };
+      `;
+
+			const result = getIdentifierType(code, "product");
+			expect(result.success).toBe(true);
+			expect(result.type).toContain("Product");
+		});
+
+		it("should return type for function signatures", () => {
+			const code = `
+        function add(a: number, b: number): number {
+          return a + b;
+        }
+        
+        const multiply = (x: number, y: number): number => x * y;
+      `;
+
+			const addType = getIdentifierType(code, "add");
+			expect(addType.success).toBe(true);
+			expect(addType.type).toMatch(/function|=>/);
+			expect(addType.type).toContain("number");
+
+			const multiplyType = getIdentifierType(code, "multiply");
+			expect(multiplyType.success).toBe(true);
+			expect(multiplyType.type).toMatch(/=>/);
+			expect(multiplyType.type).toContain("number");
+		});
+
+		it("should handle non-existent identifiers", () => {
+			const code = `
+        const existing = "value";
+      `;
+
+			const result = getIdentifierType(code, "nonExistent");
+			expect(result.success).toBe(false);
+			expect(result.error).toContain("not found");
+		});
+	});
+
+	describe("expectIdentifierType", () => {
+		it("should match exact types", () => {
+			const code = `
+        const text: string = "Hello";
+        const num: number = 42;
+      `;
+
+			const textResult = expectIdentifierType(code, "text", "string");
+			expect(textResult.success).toBe(true);
+			expect(textResult.matches).toBe(true);
+
+			const numResult = expectIdentifierType(code, "num", "number");
+			expect(numResult.success).toBe(true);
+			expect(numResult.matches).toBe(true);
+		});
+
+		it("should match with regex patterns", () => {
+			const code = `
+        const arr: string[] = ["one", "two"];
+        const tuple: [string, number] = ["hello", 42];
+      `;
+
+			const arrResult = expectIdentifierType(code, "arr", /string.*\[\]/);
+			expect(arrResult.success).toBe(true);
+			expect(arrResult.matches).toBe(true);
+
+			const tupleResult = expectIdentifierType(code, "tuple", /\[string,\s*number\]/);
+			expect(tupleResult.success).toBe(true);
+			expect(tupleResult.matches).toBe(true);
+		});
+
+		it("should detect type mismatches", () => {
+			const code = `
+        const value: string = "text";
+      `;
+
+			const result = expectIdentifierType(code, "value", "number");
+			expect(result.success).toBe(true);
+			expect(result.matches).toBe(false);
+			expect(result.actualType).toContain("string");
+		});
+
+		it("should handle complex types", () => {
+			const code = `
+        type Status = 'pending' | 'success' | 'error';
+        interface Response<T> {
+          data: T;
+          status: Status;
+        }
+        
+        const response: Response<string> = {
+          data: "result",
+          status: 'success'
+        };
+      `;
+
+			const result = expectIdentifierType(code, "response", /Response<string>/);
+			expect(result.success).toBe(true);
+			expect(result.matches).toBe(true);
+		});
+	});
+});

package/src/index.ts

@@ -0,0 +1,2 @@
+export * from "./types/index.ts";
+export * from "./validation.ts";

package/src/types/hover.ts

@@ -0,0 +1,23 @@
+/**
+ * Result of a hover operation
+ */
+export interface HoverResult {
+	success: boolean;
+	/** The inferred type at the position */
+	type?: string;
+	/** Documentation or additional information */
+	documentation?: string;
+	/** Error message if hover failed */
+	error?: string;
+}
+
+/**
+ * Options for hover operations
+ */
+export interface HoverOptions {
+	strict?: boolean;
+	/**
+	 * Path to the directory containing GIR type definitions (@types folder)
+	 */
+	typesPath?: string;
+} 

package/src/types/index.ts

@@ -0,0 +1,3 @@
+export * from "./validation.ts";
+export * from "./hover.ts";
+export * from "./type-expectation.ts"; 

package/src/types/type-expectation.ts

@@ -0,0 +1,16 @@
+/**
+ * Result of a type expectation validation
+ */
+export interface TypeExpectationResult {
+	success: boolean;
+	/** Whether the actual type matches the expected type */
+	matches: boolean;
+	/** The actual inferred type */
+	actualType?: string;
+	/** The expected type or pattern */
+	expectedType: string | RegExp;
+	/** Documentation or additional information */
+	documentation?: string;
+	/** Error message if validation failed */
+	error?: string;
+} 

package/src/types/validation.ts

@@ -0,0 +1,19 @@
+/**
+ * Result of a TypeScript validation operation
+ */
+export interface ValidationResult {
+	success: boolean;
+	errors: string[];
+	warnings: string[];
+}
+
+/**
+ * Options for TypeScript validation operations
+ */
+export interface ValidationOptions {
+	strict?: boolean;
+	/**
+	 * Path to the directory containing GIR type definitions (@types folder)
+	 */
+	typesPath?: string;
+} 

package/src/utils/index.ts

@@ -0,0 +1,3 @@
+export * from "./path.ts";
+export * from "./string.ts";
+export * from "./typescript.ts";

package/src/utils/path.ts

@@ -0,0 +1,34 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+
+/**
+ * Common paths where GIR types might be located
+ */
+export const COMMON_TYPES_PATHS = [
+	path.resolve("./@types"),
+	path.resolve("../@types"),
+	path.resolve("../../@types"),
+	path.resolve("./types"),
+	path.resolve("../types"),
+	path.resolve("../../types"),
+] as const;
+
+/**
+ * Find the first available types directory that contains .d.ts files
+ */
+export function findTypesPath(): string | undefined {
+	for (const possiblePath of COMMON_TYPES_PATHS) {
+		try {
+			if (fs.existsSync(possiblePath)) {
+				// Check if it contains .d.ts files
+				const files = fs.readdirSync(possiblePath);
+				if (files.some((file) => file.endsWith(".d.ts"))) {
+					return possiblePath;
+				}
+			}
+		} catch {
+			// Continue to next path
+		}
+	}
+	return undefined;
+}

package/src/utils/string.ts

@@ -0,0 +1,48 @@
+/**
+ * Helper function to normalize type strings for comparison
+ */
+export function normalizeTypeString(typeString: string): string {
+	// Remove extra whitespace and normalize common type variations
+	return (
+		typeString
+			.trim()
+			.replace(/\s+/g, " ")
+			// Normalize union types (remove spaces around |)
+			.replace(/\s*\|\s*/g, "|")
+			// Normalize array types
+			.replace(/Array<(.+)>/g, "$1[]")
+			// Remove import() type wrappers for comparison
+			.replace(/import\(".*?"\)\./g, "")
+	);
+}
+
+/**
+ * Check if two type strings match, considering type aliases and normalization
+ */
+export function typesMatch(actual: string, expected: string | RegExp): boolean {
+	// If expected is a RegExp, test against the actual type
+	if (expected instanceof RegExp) {
+		return expected.test(actual);
+	}
+
+	const normalizedActual = normalizeTypeString(actual);
+	const normalizedExpected = normalizeTypeString(expected);
+
+	// Direct match
+	if (normalizedActual === normalizedExpected) {
+		return true;
+	}
+
+	// Check for common type aliases
+	const typeAliases = new Map([
+		["number", "Number"],
+		["string", "String"],
+		["boolean", "Boolean"],
+		["object", "Object"],
+	]);
+
+	// Check both directions of type aliases
+	return (
+		typeAliases.get(normalizedActual) === normalizedExpected || typeAliases.get(normalizedExpected) === normalizedActual
+	);
+}

package/src/utils/typescript.ts

@@ -0,0 +1,161 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+import * as ts from "typescript";
+import type { HoverOptions } from "../types/index.ts";
+
+/**
+ * Create TypeScript compiler options optimized for GJS/GIR types
+ */
+export function createCompilerOptions(strict?: boolean): ts.CompilerOptions {
+	return {
+		target: ts.ScriptTarget.ESNext,
+		module: ts.ModuleKind.ESNext,
+		moduleResolution: ts.ModuleResolutionKind.Bundler,
+		skipLibCheck: true,
+		strict: strict ?? true,
+		noImplicitAny: true,
+		strictNullChecks: true,
+		noImplicitThis: true,
+		alwaysStrict: true,
+		noEmit: true,
+		allowSyntheticDefaultImports: true,
+		esModuleInterop: true,
+	};
+}
+
+/**
+ * Create a virtual file system for type definitions
+ */
+export function createVirtualFileSystem(typesPath?: string): Map<string, string> {
+	const virtualFileSystem = new Map<string, string>();
+
+	if (!typesPath) {
+		return virtualFileSystem;
+	}
+
+	try {
+		const files = fs.readdirSync(typesPath);
+		for (const file of files) {
+			if (file.endsWith(".d.ts")) {
+				const filePath = path.resolve(typesPath, file);
+				const content = fs.readFileSync(filePath, "utf-8");
+				// Store with full path for primary access
+				virtualFileSystem.set(filePath, content);
+				// Also store with relative path for triple-slash references
+				virtualFileSystem.set(`./${file}`, content);
+				virtualFileSystem.set(`./types/${file}`, content);
+				virtualFileSystem.set(`@types/${file}`, content);
+			}
+		}
+	} catch {
+		// Types path not accessible, continue without types
+	}
+
+	return virtualFileSystem;
+}
+
+/**
+ * Create a TypeScript compiler host with virtual file system support
+ */
+export function createCompilerHost(
+	compilerOptions: ts.CompilerOptions,
+	sourceFile: ts.SourceFile,
+	virtualFileSystem: Map<string, string>,
+	fileName: string,
+): ts.CompilerHost {
+	const host = ts.createCompilerHost(compilerOptions);
+
+	// Override file resolution to use virtual file system
+	const originalGetSourceFile = host.getSourceFile;
+	host.getSourceFile = (name, languageVersion) => {
+		if (name === fileName) {
+			return sourceFile;
+		}
+
+		// Check virtual file system first
+		if (virtualFileSystem.has(name)) {
+			const content = virtualFileSystem.get(name);
+			if (content !== undefined) {
+				return ts.createSourceFile(name, content, languageVersion, true);
+			}
+		}
+
+		// Check for relative path references
+		const baseName = path.basename(name);
+		if (virtualFileSystem.has(baseName)) {
+			const content = virtualFileSystem.get(baseName);
+			if (content !== undefined) {
+				return ts.createSourceFile(name, content, languageVersion, true);
+			}
+		}
+
+		return originalGetSourceFile.call(host, name, languageVersion);
+	};
+
+	return host;
+}
+
+/**
+ * Create a TypeScript program with virtual file system support
+ */
+export function createTypeScriptProgram(code: string, options: HoverOptions = {}) {
+	const fileName = "test.ts";
+	const sourceFile = ts.createSourceFile(fileName, code, ts.ScriptTarget.ESNext, true);
+
+	const compilerOptions = createCompilerOptions(options.strict);
+	const virtualFileSystem = createVirtualFileSystem(options.typesPath);
+	const host = createCompilerHost(compilerOptions, sourceFile, virtualFileSystem, fileName);
+
+	// Files to include in the program
+	const filesToInclude = [fileName];
+
+	// Include index.d.ts if available
+	if (options.typesPath) {
+		const indexPath = path.resolve(options.typesPath, "index.d.ts");
+		if (virtualFileSystem.has(indexPath)) {
+			filesToInclude.push(indexPath);
+		}
+	}
+
+	const program = ts.createProgram(filesToInclude, compilerOptions, host);
+
+	return { program, sourceFile };
+}
+
+/**
+ * Find the position of a variable or identifier in TypeScript code
+ */
+export function findIdentifierPosition(sourceFile: ts.SourceFile, identifier: string): number | undefined {
+	let position: number | undefined;
+
+	function visit(node: ts.Node): void {
+		if (ts.isIdentifier(node) && node.text === identifier) {
+			// Prefer variable declarations over references
+			if (ts.isVariableDeclaration(node.parent) && node.parent.name === node) {
+				position = node.getStart();
+				return;
+			}
+			// Fall back to any identifier if no declaration found
+			if (position === undefined) {
+				position = node.getStart();
+			}
+		}
+		ts.forEachChild(node, visit);
+	}
+
+	visit(sourceFile);
+	return position;
+}
+
+/**
+ * Get the node at a specific position in the source file
+ */
+export function getNodeAtPosition(sourceFile: ts.SourceFile, position: number): ts.Node | undefined {
+	function find(node: ts.Node): ts.Node | undefined {
+		if (position >= node.getStart() && position < node.getEnd()) {
+			return ts.forEachChild(node, find) || node;
+		}
+		return undefined;
+	}
+	return find(sourceFile);
+}

package/src/validation.ts

@@ -0,0 +1,303 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+import * as ts from "typescript";
+import type {
+	HoverOptions,
+	HoverResult,
+	TypeExpectationResult,
+	ValidationOptions,
+	ValidationResult,
+} from "./types/index.ts";
+import { findTypesPath } from "./utils/path.ts";
+import { typesMatch } from "./utils/string.ts";
+import { createTypeScriptProgram, findIdentifierPosition, getNodeAtPosition } from "./utils/typescript.ts";
+
+/**
+ * TypeScript validation for generated GIR types
+ */
+export function validateTypeScript(code: string, options: ValidationOptions = {}): ValidationResult {
+	try {
+		// Compiler options optimized for GJS/GIR types
+		const compilerOptions: ts.CompilerOptions = {
+			target: ts.ScriptTarget.ESNext,
+			module: ts.ModuleKind.ESNext,
+			// Don't specify lib to let TypeScript use defaults for target
+			moduleResolution: ts.ModuleResolutionKind.Bundler,
+			skipLibCheck: true, // Skip lib checking to avoid path resolution issues
+			strict: options.strict ?? true,
+			noImplicitAny: true,
+			strictNullChecks: true,
+			noImplicitThis: true,
+			alwaysStrict: true,
+			noEmit: true,
+			// Allow module resolution for GIR modules
+			allowSyntheticDefaultImports: true,
+			esModuleInterop: true,
+		};
+
+		// Create source file
+		const fileName = "test.ts";
+		const sourceFile = ts.createSourceFile(fileName, code, ts.ScriptTarget.ESNext, true);
+
+		// Files to include in the program
+		const filesToInclude = [fileName];
+
+		// Create virtual file system for type definitions
+		const virtualFileSystem = new Map<string, string>();
+
+		// Load all type definition files if types path is provided
+		if (options.typesPath) {
+			try {
+				const files = fs.readdirSync(options.typesPath);
+				for (const file of files) {
+					if (file.endsWith(".d.ts")) {
+						const filePath = path.resolve(options.typesPath, file);
+						const content = fs.readFileSync(filePath, "utf-8");
+						// Store with full path for primary access
+						virtualFileSystem.set(filePath, content);
+						// Also store with relative path for triple-slash references
+						virtualFileSystem.set(`./${file}`, content);
+						virtualFileSystem.set(`./types/${file}`, content);
+						virtualFileSystem.set(`@types/${file}`, content);
+					}
+				}
+			} catch {
+				// Types path not accessible, continue without types
+			}
+		}
+
+		// Include index.d.ts if available
+		if (options.typesPath) {
+			const indexPath = path.resolve(options.typesPath, "index.d.ts");
+			if (virtualFileSystem.has(indexPath)) {
+				filesToInclude.push(indexPath);
+			}
+		}
+
+		// Create compiler host
+		const host = ts.createCompilerHost(compilerOptions);
+
+		// Override file resolution to use virtual file system
+		const originalGetSourceFile = host.getSourceFile;
+		host.getSourceFile = (name, languageVersion) => {
+			if (name === fileName) {
+				return sourceFile;
+			}
+
+			// Check virtual file system first
+			if (virtualFileSystem.has(name)) {
+				const content = virtualFileSystem.get(name);
+				if (content !== undefined) {
+					return ts.createSourceFile(name, content, languageVersion, true);
+				}
+			}
+
+			// Check for relative path references
+			const baseName = path.basename(name);
+			if (virtualFileSystem.has(baseName)) {
+				const content = virtualFileSystem.get(baseName);
+				if (content !== undefined) {
+					return ts.createSourceFile(name, content, languageVersion, true);
+				}
+			}
+
+			return originalGetSourceFile.call(host, name, languageVersion);
+		};
+
+		// Create program and get diagnostics
+		const program = ts.createProgram(filesToInclude, compilerOptions, host);
+		const diagnostics = ts.getPreEmitDiagnostics(program, sourceFile);
+
+		const errors: string[] = [];
+		const warnings: string[] = [];
+
+		for (const diagnostic of diagnostics) {
+			const message = ts.flattenDiagnosticMessageText(diagnostic.messageText, "\n");
+
+			if (diagnostic.category === ts.DiagnosticCategory.Error) {
+				errors.push(message);
+			} else if (diagnostic.category === ts.DiagnosticCategory.Warning) {
+				warnings.push(message);
+			}
+		}
+
+		return {
+			success: errors.length === 0,
+			errors,
+			warnings,
+		};
+	} catch (error) {
+		return {
+			success: false,
+			errors: [`Validation failed: ${error}`],
+			warnings: [],
+		};
+	}
+}
+
+/**
+ * Validate GIR TypeScript code with type definitions
+ */
+export function validateGIRTypeScript(
+	code: string,
+	typesPath: string,
+	options: Omit<ValidationOptions, "typesPath"> = {},
+): ValidationResult {
+	return validateTypeScript(code, {
+		...options,
+		typesPath,
+	});
+}
+
+/**
+ * Validate GIR TypeScript code with automatic type discovery
+ * Automatically finds and includes GIR type definitions from common locations
+ */
+export function validateGIRTypeScriptAuto(
+	code: string,
+	options: Omit<ValidationOptions, "typesPath"> = {},
+): ValidationResult {
+	const typesPath = findTypesPath();
+	return validateTypeScript(code, {
+		...options,
+		typesPath,
+	});
+}
+
+/**
+ * Get type information for a specific identifier in TypeScript code
+ */
+export function getIdentifierType(code: string, identifier: string, options: HoverOptions = {}): HoverResult {
+	try {
+		const { program, sourceFile } = createTypeScriptProgram(code, options);
+
+		// Find the position of the identifier
+		const position = findIdentifierPosition(sourceFile, identifier);
+		if (position === undefined) {
+			return {
+				success: false,
+				error: `Identifier '${identifier}' not found in code`,
+			};
+		}
+
+		// Get type checker
+		const typeChecker = program.getTypeChecker();
+
+		// Find the node at the position
+		const node = getNodeAtPosition(sourceFile, position);
+		if (!node) {
+			return {
+				success: false,
+				error: `No node found at position ${position}`,
+			};
+		}
+
+		// Get the type of the node
+		const type = typeChecker.getTypeAtLocation(node);
+		const typeString = typeChecker.typeToString(type);
+
+		// Get symbol information for documentation
+		const symbol = typeChecker.getSymbolAtLocation(node);
+		const documentation = symbol
+			?.getDocumentationComment(typeChecker)
+			?.map((part) => part.text)
+			?.join("\n");
+
+		return {
+			success: true,
+			type: typeString,
+			documentation: documentation || undefined,
+		};
+	} catch (error) {
+		return {
+			success: false,
+			error: `Type checking failed: ${error}`,
+		};
+	}
+}
+
+/**
+ * Get type information for a specific identifier in TypeScript code with automatic type discovery
+ */
+export function getIdentifierTypeAuto(
+	code: string,
+	identifier: string,
+	options: Omit<HoverOptions, "typesPath"> = {},
+): HoverResult {
+	const typesPath = findTypesPath();
+	return getIdentifierType(code, identifier, {
+		...options,
+		typesPath,
+	});
+}
+
+/**
+ * Validate that a specific identifier has the expected type
+ */
+export function expectIdentifierType(
+	code: string,
+	identifier: string,
+	expectedType: string | RegExp,
+	options: HoverOptions = {},
+): TypeExpectationResult {
+	try {
+		// First get the actual type
+		const hoverResult = getIdentifierType(code, identifier, options);
+
+		if (!hoverResult.success) {
+			return {
+				success: false,
+				matches: false,
+				expectedType,
+				error: hoverResult.error,
+			};
+		}
+
+		const actualType = hoverResult.type;
+		if (!actualType) {
+			return {
+				success: false,
+				matches: false,
+				expectedType,
+				error: "No type information available",
+			};
+		}
+
+		// Check if types match
+		const matches = typesMatch(actualType, expectedType);
+
+		const expectedTypeDisplay = expectedType instanceof RegExp ? expectedType.toString() : expectedType;
+
+		return {
+			success: true,
+			matches,
+			actualType,
+			expectedType,
+			documentation: hoverResult.documentation,
+			error: matches ? undefined : `Expected type '${expectedTypeDisplay}' but got '${actualType}'`,
+		};
+	} catch (error) {
+		return {
+			success: false,
+			matches: false,
+			expectedType,
+			error: `Type expectation validation failed: ${error}`,
+		};
+	}
+}
+
+/**
+ * Validate that a specific identifier has the expected type with automatic type discovery
+ */
+export function expectIdentifierTypeAuto(
+	code: string,
+	identifier: string,
+	expectedType: string | RegExp,
+	options: Omit<HoverOptions, "typesPath"> = {},
+): TypeExpectationResult {
+	const typesPath = findTypesPath();
+	return expectIdentifierType(code, identifier, expectedType, {
+		...options,
+		typesPath,
+	});
+}

package/tsconfig.json

@@ -0,0 +1,25 @@
+{
+	"compilerOptions": {
+		"lib": ["ESNext"],
+		"target": "ESNext",
+		"module": "ESNext",
+		"outDir": "lib",
+		"strict": true,
+		"noImplicitAny": false,
+		"strictNullChecks": true,
+		"noImplicitThis": true,
+		"alwaysStrict": true,
+		"esModuleInterop": true,
+		"moduleResolution": "bundler",
+		"allowImportingTsExtensions": true,
+		"verbatimModuleSyntax": true,
+		"noEmit": true,
+		"rootDir": "src",
+		"resolveJsonModule": true,
+		"skipLibCheck": true,
+		"diagnostics": true,
+		"types": ["vitest/globals"]
+	},
+	"include": ["src/**/*.ts"],
+	"exclude": ["lib", "node_modules", "**/*.spec.ts"]
+}

package/vitest.config.ts

@@ -0,0 +1,11 @@
+import { defineConfig } from "vitest/config";
+
+export default defineConfig({
+	test: {
+		environment: "node",
+		include: ["src/**/*.test.ts", "src/**/*.spec.ts"],
+		testTimeout: 10000,
+		hookTimeout: 10000,
+		globals: true,
+	},
+});