@lspeasy/core 1.0.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024-present Pradeep Mouli
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,550 @@
+# @lspeasy/core
+
+Core transport layer and utilities for the lspeasy Language Server Protocol SDK.
+
+## Overview
+
+`@lspeasy/core` provides the foundational building blocks for LSP communication:
+
+- **Transport Interface**: Abstract transport layer for message exchange
+- **StdioTransport**: Standard input/output transport implementation
+- **WebSocketTransport**: WebSocket transport with automatic reconnection
+- **Middleware Pipeline**: Composable JSON-RPC interception with method scoping and typing
+- **JSON-RPC 2.0**: Message framing, parsing, and serialization
+- **Type-Safe Enums**: Enums for all LSP kind types with extensibility support
+- **Cancellation**: Token-based cancellation support
+- **Utilities**: Event emitters, disposables, logging, and document sync helpers
+
+## Middleware API
+
+Middleware is exported from `@lspeasy/core/middleware`.
+
+```typescript
+import {
+  composeMiddleware,
+  createScopedMiddleware,
+  createTypedMiddleware,
+  type Middleware
+} from '@lspeasy/core/middleware';
+
+const logging: Middleware = async (context, next) => {
+  console.log(`${context.direction} ${context.messageType} ${context.method}`);
+  await next();
+};
+
+const scoped = createScopedMiddleware(
+  { methods: /^textDocument\//, direction: 'clientToServer', messageType: ['request'] },
+  async (context, next) => {
+    context.metadata.startedAt = Date.now();
+    await next();
+  }
+);
+
+const typed = createTypedMiddleware('textDocument/hover', async (context, next) => {
+  console.log(context.params?.position);
+  await next();
+});
+
+export const middleware = composeMiddleware(logging, scoped, typed);
+```
+
+## Native WebSocket Support
+
+- `createWebSocketClient()` and `WebSocketTransport` use native `globalThis.WebSocket` when available.
+- Node.js `>= 22.4` is recommended for native WebSocket client support.
+- For older Node.js versions, install `ws` as an optional peer dependency.
+- WebSocket server mode (`WebSocketServer`) still requires `ws`.
+
+## Document Change Helpers
+
+Use document helpers from `@lspeasy/core/utils` to create typed didChange payloads.
+
+```typescript
+import {
+  DocumentVersionTracker,
+  createIncrementalDidChangeParams,
+  createFullDidChangeParams
+} from '@lspeasy/core/utils';
+
+const tracker = new DocumentVersionTracker();
+tracker.open('file:///demo.ts', 0);
+
+const incremental = createIncrementalDidChangeParams(
+  'file:///demo.ts',
+  [
+    {
+      range: {
+        start: { line: 0, character: 0 },
+        end: { line: 0, character: 5 }
+      },
+      text: 'const'
+    }
+  ],
+  { tracker }
+);
+
+const full = createFullDidChangeParams('file:///demo.ts', 'const value = 1;', {
+  tracker
+});
+```
+
+## Installation
+
+```bash
+npm install @lspeasy/core
+# or
+pnpm add @lspeasy/core
+# or
+yarn add @lspeasy/core
+```
+
+## Quick Start
+
+### Type-Safe LSP Enums
+
+The SDK exports enums for all LSP kind types, providing type safety and IDE autocomplete:
+
+```typescript
+import {
+  CompletionItemKind,
+  SymbolKind,
+  DiagnosticSeverity,
+  CodeActionKind,
+  FoldingRangeKind
+} from '@lspeasy/core/protocol/enums';
+
+// Use enums instead of magic numbers
+const completion = {
+  label: 'myFunction',
+  kind: CompletionItemKind.Function // Instead of: kind: 2
+};
+
+// String-based kinds support both enums and custom values
+const codeAction = {
+  title: 'Quick fix',
+  kind: CodeActionKind.QuickFix // Or custom: 'refactor.extract.helper'
+};
+```
+
+### Using StdioTransport
+
+```typescript
+import { StdioTransport } from '@lspeasy/core';
+
+// Create transport for stdio communication
+const transport = new StdioTransport();
+
+// Listen for messages
+transport.onMessage((message) => {
+  console.log('Received:', message);
+});
+
+// Send a message
+await transport.send({
+  jsonrpc: '2.0',
+  method: 'initialize',
+  id: 1,
+  params: { /* ... */ }
+});
+
+// Clean up
+await transport.close();
+```
+
+### Using WebSocketTransport
+
+```typescript
+import { WebSocketTransport } from '@lspeasy/core';
+
+// Client mode with automatic reconnection
+const transport = new WebSocketTransport({
+  url: 'ws://localhost:3000',
+  enableReconnect: true,
+  maxReconnectAttempts: 5,
+  reconnectDelay: 1000,
+  maxReconnectDelay: 30000,
+  reconnectBackoffMultiplier: 2
+});
+
+// Subscribe to events
+transport.onMessage((message) => {
+  console.log('Received:', message);
+});
+
+transport.onError((error) => {
+  console.error('Transport error:', error);
+});
+
+transport.onClose(() => {
+  console.log('Connection closed');
+});
+
+// Send messages
+await transport.send({
+  jsonrpc: '2.0',
+  method: 'textDocument/hover',
+  id: 2,
+  params: { /* ... */ }
+});
+```
+
+If running on Node.js < 22.4 and using client mode, install `ws`:
+
+```bash
+pnpm add ws
+```
+
+### Server Mode WebSocket
+
+```typescript
+import { WebSocketTransport } from '@lspeasy/core';
+import { WebSocketServer } from 'ws';
+
+const wss = new WebSocketServer({ port: 3000 });
+
+wss.on('connection', (ws) => {
+  // Wrap existing WebSocket connection
+  const transport = new WebSocketTransport({
+    socket: ws
+  });
+
+  transport.onMessage((message) => {
+    // Handle LSP messages
+  });
+});
+```
+
+## Transport Interface
+
+All transports implement the `Transport` interface:
+
+```typescript
+interface Transport {
+  // Send a JSON-RPC message
+  send(message: JSONRPCMessage): Promise<void>;
+
+  // Subscribe to incoming messages
+  onMessage(handler: (message: JSONRPCMessage) => void): Disposable;
+
+  // Subscribe to errors
+  onError(handler: (error: Error) => void): Disposable;
+
+  // Subscribe to connection close
+  onClose(handler: () => void): Disposable;
+
+  // Close the transport
+  close(): Promise<void>;
+}
+```
+
+### Creating Custom Transports
+
+You can implement custom transports for any communication protocol:
+
+```typescript
+import { Transport, Disposable, JSONRPCMessage } from '@lspeasy/core';
+import EventEmitter from 'events';
+
+class HTTPPollingTransport implements Transport {
+  private events = new EventEmitter();
+  private pollInterval: NodeJS.Timeout | null = null;
+
+  constructor(private url: string) {
+    this.startPolling();
+  }
+
+  async send(message: JSONRPCMessage): Promise<void> {
+    await fetch(`${this.url}/send`, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify(message)
+    });
+  }
+
+  onMessage(handler: (message: JSONRPCMessage) => void): Disposable {
+    this.events.on('message', handler);
+    return {
+      dispose: () => this.events.off('message', handler)
+    };
+  }
+
+  onError(handler: (error: Error) => void): Disposable {
+    this.events.on('error', handler);
+    return {
+      dispose: () => this.events.off('error', handler)
+    };
+  }
+
+  onClose(handler: () => void): Disposable {
+    this.events.on('close', handler);
+    return {
+      dispose: () => this.events.off('close', handler)
+    };
+  }
+
+  async close(): Promise<void> {
+    if (this.pollInterval) {
+      clearInterval(this.pollInterval);
+      this.pollInterval = null;
+    }
+    this.events.emit('close');
+  }
+
+  private startPolling(): void {
+    this.pollInterval = setInterval(async () => {
+      try {
+        const response = await fetch(`${this.url}/poll`);
+        const messages = await response.json();
+        for (const message of messages) {
+          this.events.emit('message', message);
+        }
+      } catch (error) {
+        this.events.emit('error', error);
+      }
+    }, 100);
+  }
+}
+```
+
+## JSON-RPC Message Utilities
+
+### Parsing and Serialization
+
+```typescript
+import { parseMessages, serializeMessage } from '@lspeasy/core';
+
+// Parse HTTP-style headers + JSON content
+const input = 'Content-Length: 59\r\n\r\n{"jsonrpc":"2.0","method":"initialize","id":1,"params":{}}';
+const messages = parseMessages(input);
+// messages = [{ jsonrpc: '2.0', method: 'initialize', id: 1, params: {} }]
+
+// Serialize back to wire format
+const output = serializeMessage(messages[0]);
+// output = 'Content-Length: 59\r\n\r\n{"jsonrpc":"2.0","method":"initialize","id":1,"params":{}}'
+```
+
+### Creating Messages
+
+```typescript
+// JSON-RPC 2.0 request message
+const request = {
+  jsonrpc: '2.0',
+  id: 1,
+  method: 'textDocument/hover',
+  params: { /* params */ },
+};
+
+// JSON-RPC 2.0 notification message (no id)
+const notification = {
+  jsonrpc: '2.0',
+  method: 'textDocument/didChange',
+  params: { /* params */ },
+};
+
+// Successful response message
+const response = {
+  jsonrpc: '2.0',
+  id: 1,
+  result: { /* result */ },
+};
+
+// Error response message
+const errorResponse = {
+  jsonrpc: '2.0',
+  id: 1,
+  error: {
+    code: -32601,
+    message: 'Method not found',
+    // optional: data: { ... },
+  },
+};
+```
+
+## Cancellation
+
+### CancellationToken
+
+```typescript
+import { CancellationTokenSource } from '@lspeasy/core';
+
+const source = new CancellationTokenSource();
+const token = source.token;
+
+// Subscribe to cancellation
+token.onCancellationRequested(() => {
+  console.log('Operation cancelled');
+});
+
+// Check if cancelled
+if (token.isCancellationRequested) {
+  return;
+}
+
+// Cancel the operation
+source.cancel();
+
+// Clean up
+source.dispose();
+```
+
+### Using with Async Operations
+
+```typescript
+async function longRunningTask(token: CancellationToken): Promise<void> {
+  for (let i = 0; i < 100; i++) {
+    if (token.isCancellationRequested) {
+      throw new Error('Operation cancelled');
+    }
+    await doWork();
+  }
+}
+
+const source = new CancellationTokenSource();
+longRunningTask(source.token).catch(console.error);
+
+// Cancel after 5 seconds
+setTimeout(() => source.cancel(), 5000);
+```
+
+## Logging
+
+```typescript
+import { ConsoleLogger, LogLevel } from '@lspeasy/core';
+
+// Create logger
+const logger = new ConsoleLogger('MyServer', LogLevel.Debug);
+
+// Log at different levels
+logger.error('Error message', new Error('Something failed'));
+logger.warn('Warning message');
+logger.info('Info message');
+logger.debug('Debug message');
+```
+
+## Error Codes
+
+Standard JSON-RPC 2.0 error codes:
+
+```typescript
+enum ErrorCode {
+  ParseError = -32700,
+  InvalidRequest = -32600,
+  MethodNotFound = -32601,
+  InvalidParams = -32602,
+  InternalError = -32603
+}
+```
+
+## Best Practices
+
+### Resource Management
+
+Always clean up resources using the Disposable pattern:
+
+```typescript
+const disposables: Disposable[] = [];
+
+disposables.push(transport.onMessage(handleMessage));
+disposables.push(transport.onError(handleError));
+disposables.push(transport.onClose(handleClose));
+
+// Later, dispose all
+disposables.forEach(d => d.dispose());
+```
+
+### Error Handling
+
+Wrap transport operations in try/catch:
+
+```typescript
+try {
+  await transport.send(message);
+} catch (error) {
+  logger.error('Failed to send message', error as Error);
+  // Handle error (reconnect, retry, etc.)
+}
+```
+
+### WebSocket Reconnection
+
+Configure reconnection parameters based on your use case:
+
+```typescript
+// Aggressive reconnection for interactive apps
+const transport = new WebSocketTransport({
+  url: 'ws://localhost:3000',
+  enableReconnect: true,
+  maxReconnectAttempts: 10,
+  reconnectDelay: 500,
+  maxReconnectDelay: 5000,
+  reconnectBackoffMultiplier: 1.5
+});
+
+// Conservative reconnection for batch processing
+const transport = new WebSocketTransport({
+  url: 'ws://localhost:3000',
+  enableReconnect: true,
+  maxReconnectAttempts: 3,
+  reconnectDelay: 5000,
+  maxReconnectDelay: 30000,
+  reconnectBackoffMultiplier: 2
+});
+```
+
+## Testing
+
+Use mock transports for testing:
+
+```typescript
+import { Transport, Disposable, JSONRPCMessage } from '@lspeasy/core';
+import EventEmitter from 'events';
+
+class MockTransport implements Transport {
+  private events = new EventEmitter();
+  public sentMessages: JSONRPCMessage[] = [];
+
+  async send(message: JSONRPCMessage): Promise<void> {
+    this.sentMessages.push(message);
+  }
+
+  onMessage(handler: (message: JSONRPCMessage) => void): Disposable {
+    this.events.on('message', handler);
+    return { dispose: () => this.events.off('message', handler) };
+  }
+
+  onError(handler: (error: Error) => void): Disposable {
+    this.events.on('error', handler);
+    return { dispose: () => this.events.off('error', handler) };
+  }
+
+  onClose(handler: () => void): Disposable {
+    this.events.on('close', handler);
+    return { dispose: () => this.events.off('close', handler) };
+  }
+
+  async close(): Promise<void> {
+    this.events.emit('close');
+  }
+
+  // Test helpers
+  simulateMessage(message: JSONRPCMessage): void {
+    this.events.emit('message', message);
+  }
+
+  simulateError(error: Error): void {
+    this.events.emit('error', error);
+  }
+}
+```
+
+## API Reference
+
+See [API.md](../../docs/API.md) for complete API documentation.
+
+## Architecture
+
+See [ARCHITECTURE.md](../../docs/ARCHITECTURE.md) for system architecture details.
+
+## License
+
+MIT

package/dist/index.d.ts

@@ -0,0 +1,44 @@
+/**
+ * @lspeasy/core - Core types, transports, and utilities for LSP SDK
+ */
+export type { BaseMessage, RequestMessage, NotificationMessage, SuccessResponseMessage, ErrorResponseMessage, ResponseMessage, Message } from './jsonrpc/messages.js';
+export type { ResponseError as ResponseErrorInterface } from './jsonrpc/messages.js';
+export { isRequestMessage, isNotificationMessage, isResponseMessage, isSuccessResponse, isErrorResponse } from './jsonrpc/messages.js';
+export { parseMessage, serializeMessage } from './jsonrpc/framing.js';
+export { MessageReader } from './jsonrpc/reader.js';
+export { MessageWriter } from './jsonrpc/writer.js';
+export { requestMessageSchema, notificationMessageSchema, responseErrorSchema, successResponseMessageSchema, errorResponseMessageSchema, responseMessageSchema, messageSchema } from './jsonrpc/schemas.js';
+export type { Transport } from './transport/transport.js';
+export { StdioTransport } from './transport/stdio.js';
+export type { StdioTransportOptions } from './transport/stdio.js';
+export { WebSocketTransport } from './transport/websocket.js';
+export type { WebSocketTransportOptions } from './transport/websocket.js';
+export { createWebSocketClient } from './transport/websocket.js';
+export { TransportEventEmitter } from './transport/events.js';
+export type { Middleware, MiddlewareContext, MiddlewareDirection, MiddlewareMessage, MiddlewareMessageType, MiddlewareNext, MiddlewareResult, MethodFilter, ScopedMiddleware, TypedMiddleware, TypedMiddlewareContext, TypedParams, TypedResult, LSPMethod } from './middleware/index.js';
+export { composeMiddleware, executeMiddlewarePipeline, createScopedMiddleware, createTypedMiddleware } from './middleware/index.js';
+export type { Disposable } from './utils/disposable.js';
+export { DisposableStore } from './utils/disposable.js';
+export type { CancellationToken } from './utils/cancellation.js';
+export { CancellationTokenSource, CancellationToken as CancellationTokenNone } from './utils/cancellation.js';
+export type { Logger } from './utils/logger.js';
+export { LogLevel, ConsoleLogger, NullLogger } from './utils/logger.js';
+export { JSONRPCErrorCode, ErrorMessage, ResponseError } from './utils/errors.js';
+export { DocumentVersionTracker, createFullDidChangeParams, createIncrementalDidChangeParams } from './utils/document.js';
+export type { IncrementalChange, VersionSource } from './utils/document.js';
+export type * from './protocol/types.js';
+export { LSPRequest, LSPNotification } from './protocol/namespaces.js';
+export * from './protocol/infer.js';
+export * from './protocol/capability-methods.js';
+export type { Client, Server } from './protocol/capability-methods.js';
+export { PositionSchema, RangeSchema, TextDocumentIdentifierSchema, HoverParamsSchema, HoverSchema, CompletionParamsSchema, CompletionItemSchema, CompletionListSchema, DefinitionParamsSchema, ReferenceParamsSchema, DocumentSymbolParamsSchema, DocumentSymbolSchema, InitializeParamsSchema, DidOpenTextDocumentParamsSchema, DidChangeTextDocumentParamsSchema, DidCloseTextDocumentParamsSchema, DidSaveTextDocumentParamsSchema, LSPSchemas, getSchemaForMethod } from './protocol/schemas.js';
+export type { WorkspaceFolder, WorkspaceFoldersChangeEvent, WorkspaceEdit, ApplyWorkspaceEditParams, ApplyWorkspaceEditResult, DidChangeWorkspaceFoldersParams } from './protocol/workspace.js';
+export { createWorkspaceFolder, createWorkspaceFoldersChangeEvent, FileChangeTypes as WorkspaceFileChangeTypes } from './protocol/workspace.js';
+export type { DidChangeWatchedFilesParams, FileEvent, FileChangeType, FileSystemWatcher, WatchKind } from './protocol/watching.js';
+export { WatchKinds, createFileEvent, createFileSystemWatcher, createDidChangeWatchedFilesParams } from './protocol/watching.js';
+export type { ProgressToken, WorkDoneProgressBegin, WorkDoneProgressReport, WorkDoneProgressEnd, WorkDoneProgressParams, WorkDoneProgressOptions, WorkDoneProgressCreateParams, WorkDoneProgressValue } from './protocol/progress.js';
+export { createProgressBegin, createProgressReport, createProgressEnd, createProgressCreateParams, createProgressToken } from './protocol/progress.js';
+export type { PartialResultParams } from './protocol/partial.js';
+export { createPartialResultParams, hasPartialResultToken, getPartialResultToken } from './protocol/partial.js';
+export * from './protocol/capabilities.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;GAEG;AAGH,YAAY,EACV,WAAW,EACX,cAAc,EACd,mBAAmB,EACnB,sBAAsB,EACtB,oBAAoB,EACpB,eAAe,EACf,OAAO,EACR,MAAM,uBAAuB,CAAC;AAG/B,YAAY,EAAE,aAAa,IAAI,sBAAsB,EAAE,MAAM,uBAAuB,CAAC;AAErF,OAAO,EACL,gBAAgB,EAChB,qBAAqB,EACrB,iBAAiB,EACjB,iBAAiB,EACjB,eAAe,EAChB,MAAM,uBAAuB,CAAC;AAE/B,OAAO,EAAE,YAAY,EAAE,gBAAgB,EAAE,MAAM,sBAAsB,CAAC;AACtE,OAAO,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAC;AACpD,OAAO,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAC;AAEpD,OAAO,EACL,oBAAoB,EACpB,yBAAyB,EACzB,mBAAmB,EACnB,4BAA4B,EAC5B,0BAA0B,EAC1B,qBAAqB,EACrB,aAAa,EACd,MAAM,sBAAsB,CAAC;AAG9B,YAAY,EAAE,SAAS,EAAE,MAAM,0BAA0B,CAAC;AAC1D,OAAO,EAAE,cAAc,EAAE,MAAM,sBAAsB,CAAC;AACtD,YAAY,EAAE,qBAAqB,EAAE,MAAM,sBAAsB,CAAC;AAClE,OAAO,EAAE,kBAAkB,EAAE,MAAM,0BAA0B,CAAC;AAC9D,YAAY,EAAE,yBAAyB,EAAE,MAAM,0BAA0B,CAAC;AAC1E,OAAO,EAAE,qBAAqB,EAAE,MAAM,0BAA0B,CAAC;AACjE,OAAO,EAAE,qBAAqB,EAAE,MAAM,uBAAuB,CAAC;AAG9D,YAAY,EACV,UAAU,EACV,iBAAiB,EACjB,mBAAmB,EACnB,iBAAiB,EACjB,qBAAqB,EACrB,cAAc,EACd,gBAAgB,EAChB,YAAY,EACZ,gBAAgB,EAChB,eAAe,EACf,sBAAsB,EACtB,WAAW,EACX,WAAW,EACX,SAAS,EACV,MAAM,uBAAuB,CAAC;AAC/B,OAAO,EACL,iBAAiB,EACjB,yBAAyB,EACzB,sBAAsB,EACtB,qBAAqB,EACtB,MAAM,uBAAuB,CAAC;AAG/B,YAAY,EAAE,UAAU,EAAE,MAAM,uBAAuB,CAAC;AACxD,OAAO,EAAE,eAAe,EAAE,MAAM,uBAAuB,CAAC;AAExD,YAAY,EAAE,iBAAiB,EAAE,MAAM,yBAAyB,CAAC;AACjE,OAAO,EACL,uBAAuB,EACvB,iBAAiB,IAAI,qBAAqB,EAC3C,MAAM,yBAAyB,CAAC;AAEjC,YAAY,EAAE,MAAM,EAAE,MAAM,mBAAmB,CAAC;AAChD,OAAO,EAAE,QAAQ,EAAE,aAAa,EAAE,UAAU,EAAE,MAAM,mBAAmB,CAAC;AAExE,OAAO,EAAE,gBAAgB,EAAE,YAAY,EAAE,aAAa,EAAE,MAAM,mBAAmB,CAAC;AAClF,OAAO,EACL,sBAAsB,EACtB,yBAAyB,EACzB,gCAAgC,EACjC,MAAM,qBAAqB,CAAC;AAC7B,YAAY,EAAE,iBAAiB,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAC;AAG5E,mBAAmB,qBAAqB,CAAC;AAIzC,OAAO,EAAE,UAAU,EAAE,eAAe,EAAE,MAAM,0BAA0B,CAAC;AACvE,cAAc,qBAAqB,CAAC;AAGpC,cAAc,kCAAkC,CAAC;AACjD,YAAY,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,kCAAkC,CAAC;AAGvE,OAAO,EACL,cAAc,EACd,WAAW,EACX,4BAA4B,EAC5B,iBAAiB,EACjB,WAAW,EACX,sBAAsB,EACtB,oBAAoB,EACpB,oBAAoB,EACpB,sBAAsB,EACtB,qBAAqB,EACrB,0BAA0B,EAC1B,oBAAoB,EACpB,sBAAsB,EACtB,+BAA+B,EAC/B,iCAAiC,EACjC,gCAAgC,EAChC,+BAA+B,EAC/B,UAAU,EACV,kBAAkB,EACnB,MAAM,uBAAuB,CAAC;AAG/B,YAAY,EACV,eAAe,EACf,2BAA2B,EAC3B,aAAa,EACb,wBAAwB,EACxB,wBAAwB,EACxB,+BAA+B,EAChC,MAAM,yBAAyB,CAAC;AACjC,OAAO,EACL,qBAAqB,EACrB,iCAAiC,EACjC,eAAe,IAAI,wBAAwB,EAC5C,MAAM,yBAAyB,CAAC;AAEjC,YAAY,EACV,2BAA2B,EAC3B,SAAS,EACT,cAAc,EACd,iBAAiB,EACjB,SAAS,EACV,MAAM,wBAAwB,CAAC;AAChC,OAAO,EACL,UAAU,EACV,eAAe,EACf,uBAAuB,EACvB,iCAAiC,EAClC,MAAM,wBAAwB,CAAC;AAEhC,YAAY,EACV,aAAa,EACb,qBAAqB,EACrB,sBAAsB,EACtB,mBAAmB,EACnB,sBAAsB,EACtB,uBAAuB,EACvB,4BAA4B,EAC5B,qBAAqB,EACtB,MAAM,wBAAwB,CAAC;AAChC,OAAO,EACL,mBAAmB,EACnB,oBAAoB,EACpB,iBAAiB,EACjB,0BAA0B,EAC1B,mBAAmB,EACpB,MAAM,wBAAwB,CAAC;AAEhC,YAAY,EAAE,mBAAmB,EAAE,MAAM,uBAAuB,CAAC;AAEjE,OAAO,EACL,yBAAyB,EACzB,qBAAqB,EACrB,qBAAqB,EACtB,MAAM,uBAAuB,CAAC;AAE/B,cAAc,4BAA4B,CAAC"}

package/dist/index.js

@@ -0,0 +1,32 @@
+/**
+ * @lspeasy/core - Core types, transports, and utilities for LSP SDK
+ */
+export { isRequestMessage, isNotificationMessage, isResponseMessage, isSuccessResponse, isErrorResponse } from './jsonrpc/messages.js';
+export { parseMessage, serializeMessage } from './jsonrpc/framing.js';
+export { MessageReader } from './jsonrpc/reader.js';
+export { MessageWriter } from './jsonrpc/writer.js';
+export { requestMessageSchema, notificationMessageSchema, responseErrorSchema, successResponseMessageSchema, errorResponseMessageSchema, responseMessageSchema, messageSchema } from './jsonrpc/schemas.js';
+export { StdioTransport } from './transport/stdio.js';
+export { WebSocketTransport } from './transport/websocket.js';
+export { createWebSocketClient } from './transport/websocket.js';
+export { TransportEventEmitter } from './transport/events.js';
+export { composeMiddleware, executeMiddlewarePipeline, createScopedMiddleware, createTypedMiddleware } from './middleware/index.js';
+export { DisposableStore } from './utils/disposable.js';
+export { CancellationTokenSource, CancellationToken as CancellationTokenNone } from './utils/cancellation.js';
+export { LogLevel, ConsoleLogger, NullLogger } from './utils/logger.js';
+export { JSONRPCErrorCode, ErrorMessage, ResponseError } from './utils/errors.js';
+export { DocumentVersionTracker, createFullDidChangeParams, createIncrementalDidChangeParams } from './utils/document.js';
+// LSP protocol types and constants (overloaded with same name - type and const)
+// Note: Single export statement exports both the type and const with same name
+export { LSPRequest, LSPNotification } from './protocol/namespaces.js';
+export * from './protocol/infer.js';
+// Capability-conditional method interfaces (hand-written type transformations)
+export * from './protocol/capability-methods.js';
+// LSP protocol schemas
+export { PositionSchema, RangeSchema, TextDocumentIdentifierSchema, HoverParamsSchema, HoverSchema, CompletionParamsSchema, CompletionItemSchema, CompletionListSchema, DefinitionParamsSchema, ReferenceParamsSchema, DocumentSymbolParamsSchema, DocumentSymbolSchema, InitializeParamsSchema, DidOpenTextDocumentParamsSchema, DidChangeTextDocumentParamsSchema, DidCloseTextDocumentParamsSchema, DidSaveTextDocumentParamsSchema, LSPSchemas, getSchemaForMethod } from './protocol/schemas.js';
+export { createWorkspaceFolder, createWorkspaceFoldersChangeEvent, FileChangeTypes as WorkspaceFileChangeTypes } from './protocol/workspace.js';
+export { WatchKinds, createFileEvent, createFileSystemWatcher, createDidChangeWatchedFilesParams } from './protocol/watching.js';
+export { createProgressBegin, createProgressReport, createProgressEnd, createProgressCreateParams, createProgressToken } from './protocol/progress.js';
+export { createPartialResultParams, hasPartialResultToken, getPartialResultToken } from './protocol/partial.js';
+export * from './protocol/capabilities.js';
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;GAEG;AAgBH,OAAO,EACL,gBAAgB,EAChB,qBAAqB,EACrB,iBAAiB,EACjB,iBAAiB,EACjB,eAAe,EAChB,MAAM,uBAAuB,CAAC;AAE/B,OAAO,EAAE,YAAY,EAAE,gBAAgB,EAAE,MAAM,sBAAsB,CAAC;AACtE,OAAO,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAC;AACpD,OAAO,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAC;AAEpD,OAAO,EACL,oBAAoB,EACpB,yBAAyB,EACzB,mBAAmB,EACnB,4BAA4B,EAC5B,0BAA0B,EAC1B,qBAAqB,EACrB,aAAa,EACd,MAAM,sBAAsB,CAAC;AAI9B,OAAO,EAAE,cAAc,EAAE,MAAM,sBAAsB,CAAC;AAEtD,OAAO,EAAE,kBAAkB,EAAE,MAAM,0BAA0B,CAAC;AAE9D,OAAO,EAAE,qBAAqB,EAAE,MAAM,0BAA0B,CAAC;AACjE,OAAO,EAAE,qBAAqB,EAAE,MAAM,uBAAuB,CAAC;AAmB9D,OAAO,EACL,iBAAiB,EACjB,yBAAyB,EACzB,sBAAsB,EACtB,qBAAqB,EACtB,MAAM,uBAAuB,CAAC;AAI/B,OAAO,EAAE,eAAe,EAAE,MAAM,uBAAuB,CAAC;AAGxD,OAAO,EACL,uBAAuB,EACvB,iBAAiB,IAAI,qBAAqB,EAC3C,MAAM,yBAAyB,CAAC;AAGjC,OAAO,EAAE,QAAQ,EAAE,aAAa,EAAE,UAAU,EAAE,MAAM,mBAAmB,CAAC;AAExE,OAAO,EAAE,gBAAgB,EAAE,YAAY,EAAE,aAAa,EAAE,MAAM,mBAAmB,CAAC;AAClF,OAAO,EACL,sBAAsB,EACtB,yBAAyB,EACzB,gCAAgC,EACjC,MAAM,qBAAqB,CAAC;AAM7B,gFAAgF;AAChF,+EAA+E;AAC/E,OAAO,EAAE,UAAU,EAAE,eAAe,EAAE,MAAM,0BAA0B,CAAC;AACvE,cAAc,qBAAqB,CAAC;AAEpC,+EAA+E;AAC/E,cAAc,kCAAkC,CAAC;AAGjD,uBAAuB;AACvB,OAAO,EACL,cAAc,EACd,WAAW,EACX,4BAA4B,EAC5B,iBAAiB,EACjB,WAAW,EACX,sBAAsB,EACtB,oBAAoB,EACpB,oBAAoB,EACpB,sBAAsB,EACtB,qBAAqB,EACrB,0BAA0B,EAC1B,oBAAoB,EACpB,sBAAsB,EACtB,+BAA+B,EAC/B,iCAAiC,EACjC,gCAAgC,EAChC,+BAA+B,EAC/B,UAAU,EACV,kBAAkB,EACnB,MAAM,uBAAuB,CAAC;AAW/B,OAAO,EACL,qBAAqB,EACrB,iCAAiC,EACjC,eAAe,IAAI,wBAAwB,EAC5C,MAAM,yBAAyB,CAAC;AASjC,OAAO,EACL,UAAU,EACV,eAAe,EACf,uBAAuB,EACvB,iCAAiC,EAClC,MAAM,wBAAwB,CAAC;AAYhC,OAAO,EACL,mBAAmB,EACnB,oBAAoB,EACpB,iBAAiB,EACjB,0BAA0B,EAC1B,mBAAmB,EACpB,MAAM,wBAAwB,CAAC;AAIhC,OAAO,EACL,yBAAyB,EACzB,qBAAqB,EACrB,qBAAqB,EACtB,MAAM,uBAAuB,CAAC;AAE/B,cAAc,4BAA4B,CAAC"}

package/dist/jsonrpc/framing.d.ts

@@ -0,0 +1,32 @@
+/**
+ * JSON-RPC 2.0 message framing with Content-Length headers
+ * Pattern: MCP SDK's parseMessage with header parsing
+ */
+import type { Message } from './messages.js';
+/**
+ * Header constants
+ */
+export declare const CONTENT_LENGTH_HEADER = "Content-Length";
+export declare const CONTENT_TYPE_HEADER = "Content-Type";
+export declare const DEFAULT_CONTENT_TYPE = "application/vscode-jsonrpc; charset=utf-8";
+/**
+ * Parse headers from buffer
+ * Format: "Header-Name: value\r\n"
+ */
+export declare function parseHeaders(buffer: Buffer): {
+    headers: Map<string, string>;
+    bodyStart: number;
+} | null;
+/**
+ * Parse a complete message from buffer
+ * Returns { message, bytesRead } or null if incomplete
+ */
+export declare function parseMessage(buffer: Buffer): {
+    message: Message;
+    bytesRead: number;
+} | null;
+/**
+ * Serialize a message to buffer with headers
+ */
+export declare function serializeMessage(message: Message): Buffer;
+//# sourceMappingURL=framing.d.ts.map