@difizen/libro-lsp 0.1.2

package/es/ws-connection/server-capability-registration.d.ts

@@ -0,0 +1,19 @@
+import type { Registration, ServerCapabilities, Unregistration } from 'vscode-languageserver-protocol';
+/**
+ * Register the capabilities with the server capabilities provider
+ *
+ * @param serverCapabilities - server capabilities provider.
+ * @param registration -  capabilities to be registered.
+ * @return - the new server capabilities provider
+ */
+declare function registerServerCapability(serverCapabilities: ServerCapabilities, registration: Registration): ServerCapabilities | null;
+/**
+ * Unregister the capabilities with the server capabilities provider
+ *
+ * @param serverCapabilities - server capabilities provider.
+ * @param registration -  capabilities to be unregistered.
+ * @return - the new server capabilities provider
+ */
+declare function unregisterServerCapability(serverCapabilities: ServerCapabilities, unregistration: Unregistration): ServerCapabilities;
+export { registerServerCapability, unregisterServerCapability };
+//# sourceMappingURL=server-capability-registration.d.ts.map

package/es/ws-connection/server-capability-registration.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"server-capability-registration.d.ts","sourceRoot":"","sources":["../../src/ws-connection/server-capability-registration.ts"],"names":[],"mappings":"AAWA,OAAO,KAAK,EACV,YAAY,EACZ,kBAAkB,EAClB,cAAc,EACf,MAAM,gCAAgC,CAAC;AAMxC;;;;;;GAMG;AACH,iBAAS,wBAAwB,CAC/B,kBAAkB,EAAE,kBAAkB,EACtC,YAAY,EAAE,YAAY,GACzB,kBAAkB,GAAG,IAAI,CAqB3B;AAED;;;;;;GAMG;AACH,iBAAS,0BAA0B,CACjC,kBAAkB,EAAE,kBAAkB,EACtC,cAAc,EAAE,cAAc,GAC7B,kBAAkB,CAUpB;AAED,OAAO,EAAE,wBAAwB,EAAE,0BAA0B,EAAE,CAAC"}

package/es/ws-connection/server-capability-registration.js

@@ -0,0 +1,51 @@
+/*
+ * Copyright (c) Jupyter Development Team.
+ * Distributed under the terms of the Modified BSD License.
+ */
+
+// Disclaimer/acknowledgement: Fragments are based on https://github.com/wylieconlon/lsp-editor-adapter,
+// which is copyright of wylieconlon and contributors and ISC licenced.
+// ISC licence is, quote, "functionally equivalent to the simplified BSD and MIT licenses,
+// but without language deemed unnecessary following the Berne Convention." (Wikipedia).
+// Introduced modifications are BSD licenced, copyright JupyterLab development team.
+
+/**
+ * Register the capabilities with the server capabilities provider
+ *
+ * @param serverCapabilities - server capabilities provider.
+ * @param registration -  capabilities to be registered.
+ * @return - the new server capabilities provider
+ */
+function registerServerCapability(serverCapabilities, registration) {
+  var serverCapabilitiesCopy = JSON.parse(JSON.stringify(serverCapabilities));
+  var method = registration.method,
+    registerOptions = registration.registerOptions;
+  var providerName = method.substring(13) + 'Provider';
+  if (providerName) {
+    if (!registerOptions) {
+      serverCapabilitiesCopy[providerName] = true;
+    } else {
+      serverCapabilitiesCopy[providerName] = JSON.parse(JSON.stringify(registerOptions));
+    }
+  } else {
+    console.warn('Could not register server capability.', registration);
+    return null;
+  }
+  return serverCapabilitiesCopy;
+}
+
+/**
+ * Unregister the capabilities with the server capabilities provider
+ *
+ * @param serverCapabilities - server capabilities provider.
+ * @param registration -  capabilities to be unregistered.
+ * @return - the new server capabilities provider
+ */
+function unregisterServerCapability(serverCapabilities, unregistration) {
+  var serverCapabilitiesCopy = JSON.parse(JSON.stringify(serverCapabilities));
+  var method = unregistration.method;
+  var providerName = method.substring(13) + 'Provider';
+  delete serverCapabilitiesCopy[providerName];
+  return serverCapabilitiesCopy;
+}
+export { registerServerCapability, unregisterServerCapability };

package/es/ws-connection/types.d.ts

@@ -0,0 +1,76 @@
+import type * as lsp from 'vscode-languageserver-protocol';
+export interface IDocumentInfo {
+    /**
+     * URI of the virtual document.
+     */
+    uri: string;
+    /**
+     * Version of the virtual document.
+     */
+    version: number;
+    /**
+     * Text content of the document.
+     */
+    text: string;
+    /**
+     * Language id of the document.
+     */
+    languageId: string;
+}
+export interface ILspConnection {
+    /**
+     * Is the language server is connected?
+     */
+    isConnected: boolean;
+    /**
+     * Is the language server is initialized?
+     */
+    isInitialized: boolean;
+    /**
+     * Is the language server is connected and initialized?
+     */
+    isReady: boolean;
+    /**
+     * Initialize a connection over a web socket that speaks the LSP protocol
+     */
+    connect(socket: WebSocket): void;
+    /**
+     * Close the connection
+     */
+    close(): void;
+    /**
+     * The initialize request tells the server which options the client supports
+     */
+    sendInitialize(): void;
+    /**
+     * Inform the server that the document was opened
+     */
+    sendOpen(documentInfo: IDocumentInfo): void;
+    /**
+     * Sends the full text of the document to the server
+     */
+    sendChange(documentInfo: IDocumentInfo): void;
+    /**
+     * Send save notification to the server.
+     */
+    sendSaved(documentInfo: IDocumentInfo): void;
+    /**
+     * Send configuration change to the server.
+     */
+    sendConfigurationChange(settings: lsp.DidChangeConfigurationParams): void;
+}
+export interface ILspOptions {
+    /**
+     * LSP handler endpoint.
+     */
+    serverUri: string;
+    /**
+     * Language Id.
+     */
+    languageId: string;
+    /**
+     * The root URI set by server.
+     */
+    rootUri: string;
+}
+//# sourceMappingURL=types.d.ts.map

package/es/ws-connection/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/ws-connection/types.ts"],"names":[],"mappings":"AAWA,OAAO,KAAK,KAAK,GAAG,MAAM,gCAAgC,CAAC;AAE3D,MAAM,WAAW,aAAa;IAC5B;;OAEG;IACH,GAAG,EAAE,MAAM,CAAC;IAEZ;;OAEG;IACH,OAAO,EAAE,MAAM,CAAC;IAEhB;;OAEG;IACH,IAAI,EAAE,MAAM,CAAC;IAEb;;OAEG;IACH,UAAU,EAAE,MAAM,CAAC;CACpB;AAED,MAAM,WAAW,cAAc;IAC7B;;OAEG;IACH,WAAW,EAAE,OAAO,CAAC;IACrB;;OAEG;IACH,aAAa,EAAE,OAAO,CAAC;IAEvB;;OAEG;IACH,OAAO,EAAE,OAAO,CAAC;IAEjB;;OAEG;IACH,OAAO,CAAC,MAAM,EAAE,SAAS,GAAG,IAAI,CAAC;IAEjC;;OAEG;IACH,KAAK,IAAI,IAAI,CAAC;IAGd;;OAEG;IACH,cAAc,IAAI,IAAI,CAAC;IACvB;;OAEG;IACH,QAAQ,CAAC,YAAY,EAAE,aAAa,GAAG,IAAI,CAAC;IAE5C;;OAEG;IACH,UAAU,CAAC,YAAY,EAAE,aAAa,GAAG,IAAI,CAAC;IAE9C;;OAEG;IACH,SAAS,CAAC,YAAY,EAAE,aAAa,GAAG,IAAI,CAAC;IAE7C;;OAEG;IACH,uBAAuB,CAAC,QAAQ,EAAE,GAAG,CAAC,4BAA4B,GAAG,IAAI,CAAC;CAC3E;AAED,MAAM,WAAW,WAAW;IAC1B;;OAEG;IACH,SAAS,EAAE,MAAM,CAAC;IAElB;;OAEG;IACH,UAAU,EAAE,MAAM,CAAC;IAEnB;;OAEG;IACH,OAAO,EAAE,MAAM,CAAC;CACjB"}

package/es/ws-connection/types.js

@@ -0,0 +1 @@
+export {};

package/es/ws-connection/ws-connection.d.ts

@@ -0,0 +1,105 @@
+import type { Disposable, Event } from '@difizen/mana-app';
+import { Emitter } from '@difizen/mana-app';
+import type * as protocol from 'vscode-languageserver-protocol';
+import type { MessageConnection } from 'vscode-ws-jsonrpc';
+import type { IDocumentInfo, ILspConnection, ILspOptions } from './types.js';
+export declare class LspWsConnection implements ILspConnection, Disposable {
+    constructor(options: ILspOptions);
+    /**
+     * Is the language server is connected?
+     */
+    get isConnected(): boolean;
+    /**
+     * Is the language server is initialized?
+     */
+    get isInitialized(): boolean;
+    /**
+     * Is the language server is connected and initialized?
+     */
+    get isReady(): boolean;
+    /**
+     * A signal emitted when the connection is disposed.
+     */
+    get onDisposed(): Event<void>;
+    /**
+     * Check if the connection is disposed
+     */
+    get isDisposed(): boolean;
+    /**
+     * Initialize a connection over a web socket that speaks the LSP protocol
+     */
+    connect(socket: WebSocket): void;
+    /**
+     * Close the connection
+     */
+    close(): void;
+    /**
+     * The initialize request telling the server which options the client supports
+     */
+    sendInitialize(): void;
+    /**
+     * Inform the server that the document was opened
+     */
+    sendOpen(documentInfo: IDocumentInfo): void;
+    /**
+     * Sends the full text of the document to the server
+     */
+    sendChange(documentInfo: IDocumentInfo): void;
+    /**
+     * Send save notification to the server.
+     */
+    sendSaved(documentInfo: IDocumentInfo): void;
+    /**
+     * Send configuration change to the server.
+     */
+    sendConfigurationChange(settings: protocol.DidChangeConfigurationParams): void;
+    /**
+     * Dispose the connection.
+     */
+    dispose(): void;
+    /**
+     * The internal websocket connection to the LSP handler
+     */
+    protected socket: WebSocket;
+    /**
+     * The json-rpc wrapper over the internal websocket connection.
+     */
+    protected connection: MessageConnection;
+    /**
+     * Map to track opened virtual documents..
+     */
+    protected openedUris: Map<string, boolean>;
+    /**
+     * Server capabilities provider.
+     */
+    protected serverCapabilities: protocol.ServerCapabilities;
+    /**
+     * The connection is connected?
+     */
+    protected _isConnected: boolean;
+    /**
+     * The connection is initialized?
+     */
+    protected _isInitialized: boolean;
+    /**
+     * Array of LSP callback disposables, it is used to
+     * clear the callbacks when the connection is disposed.
+     */
+    protected _disposables: protocol.Disposable[];
+    /**
+     * Callback called when the server is initialized.
+     */
+    protected onServerInitialized(params: protocol.InitializeResult): void;
+    /**
+     * Initialization parameters to be sent to the language server.
+     * Subclasses should override this when adding more features.
+     */
+    protected initializeParams(): protocol.InitializeParams;
+    /**
+     * URI of the LSP handler enpoint.
+     */
+    protected _rootUri: string;
+    protected _disposed: Emitter<void>;
+    protected _isDisposed: boolean;
+}
+//# sourceMappingURL=ws-connection.d.ts.map

package/es/ws-connection/ws-connection.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ws-connection.d.ts","sourceRoot":"","sources":["../../src/ws-connection/ws-connection.ts"],"names":[],"mappings":"AAWA,OAAO,KAAK,EAAE,UAAU,EAAE,KAAK,EAAE,MAAM,mBAAmB,CAAC;AAC3D,OAAO,EAAE,OAAO,EAAE,MAAM,mBAAmB,CAAC;AAC5C,OAAO,KAAK,KAAK,QAAQ,MAAM,gCAAgC,CAAC;AAEhE,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,mBAAmB,CAAC;AAO3D,OAAO,KAAK,EAAE,aAAa,EAAE,cAAc,EAAE,WAAW,EAAE,MAAM,YAAY,CAAC;AAE7E,qBAAa,eAAgB,YAAW,cAAc,EAAE,UAAU;gBACpD,OAAO,EAAE,WAAW;IAIhC;;OAEG;IACH,IAAI,WAAW,IAAI,OAAO,CAEzB;IAED;;OAEG;IACH,IAAI,aAAa,IAAI,OAAO,CAE3B;IAED;;OAEG;IACH,IAAI,OAAO,YAEV;IAED;;OAEG;IACH,IAAI,UAAU,IAAI,KAAK,CAAC,IAAI,CAAC,CAE5B;IAED;;OAEG;IACH,IAAI,UAAU,IAAI,OAAO,CAExB;IAED;;OAEG;IACH,OAAO,CAAC,MAAM,EAAE,SAAS,GAAG,IAAI;IAsDhC;;OAEG;IACH,KAAK;IAQL;;OAEG;IACH,cAAc;IAuBd;;OAEG;IACH,QAAQ,CAAC,YAAY,EAAE,aAAa;IAgBpC;;OAEG;IACH,UAAU,CAAC,YAAY,EAAE,aAAa;IAqBtC;;OAEG;IACH,SAAS,CAAC,YAAY,EAAE,aAAa;IAiBrC;;OAEG;IACH,uBAAuB,CAAC,QAAQ,EAAE,QAAQ,CAAC,4BAA4B;IAUvE;;OAEG;IACH,OAAO,IAAI,IAAI;IAWf;;OAEG;IACH,SAAS,CAAC,MAAM,EAAE,SAAS,CAAC;IAE5B;;OAEG;IACH,SAAS,CAAC,UAAU,EAAE,iBAAiB,CAAC;IAExC;;OAEG;IACH,SAAS,CAAC,UAAU,uBAA8B;IAElD;;OAEG;IACH,SAAS,CAAC,kBAAkB,EAAE,QAAQ,CAAC,kBAAkB,CAAC;IAE1D;;OAEG;IACH,SAAS,CAAC,YAAY,UAAS;IAE/B;;OAEG;IACH,SAAS,CAAC,cAAc,UAAS;IAEjC;;;OAGG;IACH,SAAS,CAAC,YAAY,EAAE,QAAQ,CAAC,UAAU,EAAE,CAAM;IAEnD;;OAEG;IACH,SAAS,CAAC,mBAAmB,CAAC,MAAM,EAAE,QAAQ,CAAC,gBAAgB,GAAG,IAAI;IAWtE;;;OAGG;IACH,SAAS,CAAC,gBAAgB,IAAI,QAAQ,CAAC,gBAAgB;IASvD;;OAEG;IACH,SAAS,CAAC,QAAQ,EAAE,MAAM,CAAC;IAE3B,SAAS,CAAC,SAAS,gBAAuB;IAE1C,SAAS,CAAC,WAAW,UAAS;CAC/B"}

package/es/ws-connection/ws-connection.js

@@ -0,0 +1,301 @@
+function _typeof(o) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; }, _typeof(o); }
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, _toPropertyKey(descriptor.key), descriptor); } }
+function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); Object.defineProperty(Constructor, "prototype", { writable: false }); return Constructor; }
+function _toPropertyKey(arg) { var key = _toPrimitive(arg, "string"); return _typeof(key) === "symbol" ? key : String(key); }
+function _toPrimitive(input, hint) { if (_typeof(input) !== "object" || input === null) return input; var prim = input[Symbol.toPrimitive]; if (prim !== undefined) { var res = prim.call(input, hint || "default"); if (_typeof(res) !== "object") return res; throw new TypeError("@@toPrimitive must return a primitive value."); } return (hint === "string" ? String : Number)(input); }
+/*
+ * Copyright (c) Jupyter Development Team.
+ * Distributed under the terms of the Modified BSD License.
+ */
+
+// Disclaimer/acknowledgement: Fragments are based on https://github.com/wylieconlon/lsp-editor-adapter,
+// which is copyright of wylieconlon and contributors and ISC licenced.
+// ISC licence is, quote, "functionally equivalent to the simplified BSD and MIT licenses,
+// but without language deemed unnecessary following the Berne Convention." (Wikipedia).
+// Introduced modifications are BSD licenced, copyright JupyterLab development team.
+
+import { Emitter } from '@difizen/mana-app';
+
+//TODO: vscode-ws-jsonrpc has new version
+
+import { ConsoleLogger, listen } from 'vscode-ws-jsonrpc';
+import { registerServerCapability, unregisterServerCapability } from "./server-capability-registration.js";
+export var LspWsConnection = /*#__PURE__*/function () {
+  function LspWsConnection(options) {
+    _classCallCheck(this, LspWsConnection);
+    /**
+     * Map to track opened virtual documents..
+     */
+    this.openedUris = new Map();
+    /**
+     * The connection is connected?
+     */
+    this._isConnected = false;
+    /**
+     * The connection is initialized?
+     */
+    this._isInitialized = false;
+    /**
+     * Array of LSP callback disposables, it is used to
+     * clear the callbacks when the connection is disposed.
+     */
+    this._disposables = [];
+    this._disposed = new Emitter();
+    this._isDisposed = false;
+    this._rootUri = options.rootUri;
+  }
+
+  /**
+   * Is the language server is connected?
+   */
+  _createClass(LspWsConnection, [{
+    key: "isConnected",
+    get: function get() {
+      return this._isConnected;
+    }
+
+    /**
+     * Is the language server is initialized?
+     */
+  }, {
+    key: "isInitialized",
+    get: function get() {
+      return this._isInitialized;
+    }
+
+    /**
+     * Is the language server is connected and initialized?
+     */
+  }, {
+    key: "isReady",
+    get: function get() {
+      return this._isConnected && this._isInitialized;
+    }
+
+    /**
+     * A signal emitted when the connection is disposed.
+     */
+  }, {
+    key: "onDisposed",
+    get: function get() {
+      return this._disposed.event;
+    }
+
+    /**
+     * Check if the connection is disposed
+     */
+  }, {
+    key: "isDisposed",
+    get: function get() {
+      return this._isDisposed;
+    }
+
+    /**
+     * Initialize a connection over a web socket that speaks the LSP protocol
+     */
+  }, {
+    key: "connect",
+    value: function connect(socket) {
+      var _this = this;
+      this.socket = socket;
+      listen({
+        webSocket: this.socket,
+        logger: new ConsoleLogger(),
+        onConnection: function onConnection(connection) {
+          connection.listen();
+          _this._isConnected = true;
+          _this.connection = connection;
+          _this.sendInitialize();
+          var registerCapabilityDisposable = _this.connection.onRequest('client/registerCapability', function (params) {
+            params.registrations.forEach(function (capabilityRegistration) {
+              try {
+                _this.serverCapabilities = registerServerCapability(_this.serverCapabilities, capabilityRegistration);
+              } catch (err) {
+                console.error(err);
+              }
+            });
+          });
+          _this._disposables.push(registerCapabilityDisposable);
+          var unregisterCapabilityDisposable = _this.connection.onRequest('client/unregisterCapability', function (params) {
+            params.unregisterations.forEach(function (capabilityUnregistration) {
+              _this.serverCapabilities = unregisterServerCapability(_this.serverCapabilities, capabilityUnregistration);
+            });
+          });
+          _this._disposables.push(unregisterCapabilityDisposable);
+          var disposable = _this.connection.onClose(function () {
+            _this._isConnected = false;
+          });
+          _this._disposables.push(disposable);
+        }
+      });
+    }
+
+    /**
+     * Close the connection
+     */
+  }, {
+    key: "close",
+    value: function close() {
+      if (this.connection) {
+        this.connection.dispose();
+      }
+      this.openedUris.clear();
+      this.socket.close();
+    }
+
+    /**
+     * The initialize request telling the server which options the client supports
+     */
+  }, {
+    key: "sendInitialize",
+    value: function sendInitialize() {
+      var _this2 = this;
+      if (!this._isConnected) {
+        return;
+      }
+      this.openedUris.clear();
+      var message = this.initializeParams();
+      this.connection.sendRequest('initialize', message).then(function (params) {
+        _this2.onServerInitialized(params);
+        return;
+      }, function (e) {
+        console.warn('LSP websocket connection initialization failure', e);
+      }).catch(console.error);
+    }
+
+    /**
+     * Inform the server that the document was opened
+     */
+  }, {
+    key: "sendOpen",
+    value: function sendOpen(documentInfo) {
+      var textDocumentMessage = {
+        textDocument: {
+          uri: documentInfo.uri,
+          languageId: documentInfo.languageId,
+          text: documentInfo.text,
+          version: documentInfo.version
+        }
+      };
+      this.connection.sendNotification('textDocument/didOpen', textDocumentMessage).catch(console.error);
+      this.openedUris.set(documentInfo.uri, true);
+      this.sendChange(documentInfo);
+    }
+
+    /**
+     * Sends the full text of the document to the server
+     */
+  }, {
+    key: "sendChange",
+    value: function sendChange(documentInfo) {
+      if (!this.isReady) {
+        return;
+      }
+      if (!this.openedUris.get(documentInfo.uri)) {
+        this.sendOpen(documentInfo);
+        return;
+      }
+      var textDocumentChange = {
+        textDocument: {
+          uri: documentInfo.uri,
+          version: documentInfo.version
+        },
+        contentChanges: [{
+          text: documentInfo.text
+        }]
+      };
+      this.connection.sendNotification('textDocument/didChange', textDocumentChange).catch(console.error);
+      documentInfo.version++;
+    }
+
+    /**
+     * Send save notification to the server.
+     */
+  }, {
+    key: "sendSaved",
+    value: function sendSaved(documentInfo) {
+      if (!this.isReady) {
+        return;
+      }
+      var textDocumentChange = {
+        textDocument: {
+          uri: documentInfo.uri,
+          version: documentInfo.version
+        },
+        text: documentInfo.text
+      };
+      this.connection.sendNotification('textDocument/didSave', textDocumentChange).catch(console.error);
+    }
+
+    /**
+     * Send configuration change to the server.
+     */
+  }, {
+    key: "sendConfigurationChange",
+    value: function sendConfigurationChange(settings) {
+      if (!this.isReady) {
+        return;
+      }
+      this.connection.sendNotification('workspace/didChangeConfiguration', settings).catch(console.error);
+    }
+
+    /**
+     * Dispose the connection.
+     */
+  }, {
+    key: "dispose",
+    value: function dispose() {
+      if (this._isDisposed) {
+        return;
+      }
+      this._isDisposed = true;
+      this._disposables.forEach(function (disposable) {
+        disposable.dispose();
+      });
+      this._disposed.fire();
+    }
+
+    /**
+     * The internal websocket connection to the LSP handler
+     */
+
+    /**
+     * The json-rpc wrapper over the internal websocket connection.
+     */
+  }, {
+    key: "onServerInitialized",
+    value:
+    /**
+     * Callback called when the server is initialized.
+     */
+    function onServerInitialized(params) {
+      this._isInitialized = true;
+      this.serverCapabilities = params.capabilities;
+      this.connection.sendNotification('initialized', {}).catch(console.error);
+      this.connection.sendNotification('workspace/didChangeConfiguration', {
+        settings: {}
+      }).catch(console.error);
+    }
+
+    /**
+     * Initialization parameters to be sent to the language server.
+     * Subclasses should override this when adding more features.
+     */
+  }, {
+    key: "initializeParams",
+    value: function initializeParams() {
+      return {
+        capabilities: {},
+        processId: null,
+        rootUri: this._rootUri,
+        workspaceFolders: null
+      };
+    }
+
+    /**
+     * URI of the LSP handler enpoint.
+     */
+  }]);
+  return LspWsConnection;
+}();

package/package.json

@@ -0,0 +1,67 @@
+{
+  "name": "@difizen/libro-lsp",
+  "version": "0.1.2",
+  "description": "",
+  "keywords": [
+    "libro",
+    "notebook"
+  ],
+  "repository": "git@github.com:difizen/libro.git",
+  "license": "MIT",
+  "type": "module",
+  "exports": {
+    ".": {
+      "typings": "./es/index.d.ts",
+      "default": "./es/index.js"
+    },
+    "./mock": {
+      "typings": "./es/mock/index.d.ts",
+      "default": "./es/mock/index.js"
+    },
+    "./es/mock": {
+      "typings": "./es/mock/index.d.ts",
+      "default": "./es/mock/index.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "main": "es/index.js",
+  "module": "es/index.js",
+  "typings": "es/index.d.ts",
+  "files": [
+    "es",
+    "src"
+  ],
+  "dependencies": {
+    "@difizen/libro-core": "^0.1.2",
+    "@difizen/libro-kernel": "^0.1.2",
+    "@difizen/libro-common": "^0.1.2",
+    "@difizen/libro-code-editor": "^0.1.2",
+    "@difizen/mana-app": "latest",
+    "lodash.mergewith": "^4.6.2",
+    "uuid": "^9.0.0",
+    "vscode-jsonrpc": "^6.0.0",
+    "vscode-languageserver-protocol": "^3.17.0",
+    "vscode-ws-jsonrpc": "~1.0.2"
+  },
+  "peerDependencies": {
+    "react": "^18.2.0"
+  },
+  "devDependencies": {
+    "@types/lodash.mergewith": "^4.6.9",
+    "@types/react": "^18.2.25",
+    "@types/uuid": "^9.0.2"
+  },
+  "scripts": {
+    "setup": "father build",
+    "build": "father build",
+    "test": ": Note: lint task is delegated to test:* scripts",
+    "test:vitest": "vitest run",
+    "test:jest": "jest",
+    "coverage": ": Note: lint task is delegated to coverage:* scripts",
+    "coverage:vitest": "vitest run --coverage",
+    "coverage:jest": "jest --coverage",
+    "lint": ": Note: lint task is delegated to lint:* scripts",
+    "lint:eslint": "eslint src",
+    "lint:tsc": "tsc --noEmit"
+  }
+}