♻️ extract lifecycle into its own module

Author: cowboyd

lib/lifecycle.ts

@@ -0,0 +1,103 @@
+import type { Operation, Stream } from "effection";
+import { all, call, createChannel } from "effection";
+import type { LSPAgent, RPCEndpoint } from "./types.ts";
+import { ErrorCodes } from "vscode-jsonrpc";
+import type { InitializeResult } from "vscode-languageserver-protocol";
+import { responseError } from "./json-rpc-connection.ts";
+import * as merge from "./merge.ts";
+
+export interface State {
+  notify: RPCEndpoint["notify"];
+  request: RPCEndpoint["request"];
+}
+
+export function lifecycle(
+  servers: RPCEndpoint[],
+): [State, Stream<State, void>] {
+  let states = createChannel<State, void>();
+  return [uninitializedState(servers, states.send), states];
+}
+
+function uninitializedState(
+  servers: RPCEndpoint[],
+  transition: (state: State) => Operation<void>,
+): State {
+  return {
+    *notify() {},
+    *request(params) {
+      let [method] = params;
+      if (method !== "initialize") {
+        yield* responseError(
+          ErrorCodes.ServerNotInitialized,
+          `server not initialized`,
+        );
+      }
+      let agents = yield* all(servers.map((server) =>
+        call(function* () {
+          let initialization = yield* server.request<InitializeResult>(
+            params,
+          );
+          let { capabilities } = initialization;
+          return {
+            ...server,
+            initialization,
+            capabilities,
+          } as LSPAgent;
+        })
+      ));
+
+      yield* transition(initializedState(agents, transition));
+
+      return cast(merge.capabilities(agents));
+    },
+  };
+}
+
+function initializedState(
+  agents: LSPAgent[],
+  transition: (state: State) => Operation<void>,
+): State {
+  return {
+    *notify(params) {
+      // TODO: only forward notifications to interested agents
+      for (let agent of agents) {
+        yield* agent.notify(params);
+      }
+    },
+    *request(params) {
+      let [first] = agents;
+      let [method] = params;
+      if (method === "initialize") {
+        yield* responseError(
+          ErrorCodes.InvalidRequest,
+          `initialize invoked twice`,
+        );
+      } else if (method === "shutdown") {
+        yield* transition(shutdownState);
+        for (let agent of agents) {
+          yield* agent.request(params);
+        }
+        return cast(null);
+      } else if (!first) {
+        throw yield* responseError(
+          ErrorCodes.InternalError,
+          `no lsps to make requests`,
+        );
+      }
+
+      return yield* first.request(params);
+    },
+  };
+}
+
+const shutdownState: State = {
+  *notify() {},
+  *request() {
+    return yield* responseError(
+      ErrorCodes.InvalidRequest,
+      `server is shut down`,
+    );
+  },
+};
+
+const cast = <T>(value: unknown) => value as T;

lib/multiplexer.ts

@@ -1,17 +1,11 @@
 import type { Operation } from "effection";
-import { all, call, createChannel, each, resource, spawn } from "effection";
-
+import { createChannel, each, resource, spawn } from "effection";
 import type {
-  LSPAgent,
   LSPServerRequest,
   NotificationParams,
-  RequestParams,
   RPCEndpoint,
 } from "./types.ts";
-import { ErrorCodes } from "vscode-jsonrpc";
-import type { InitializeResult } from "vscode-languageserver-protocol";
-import { responseError } from "./json-rpc-connection.ts";
-import * as merge from "./merge.ts";
+import { lifecycle } from "./lifecycle.ts";
 
 export interface MultiplexerOptions {
   servers: RPCEndpoint[];
@@ -44,8 +38,7 @@ export function useMultiplexer(
     }
 
     // delegate notifications and requests from client -> server to current state
-    let states = createChannel<State, never>();
-    let state = uninitialized(servers, states.send);
+    let [state, states] = lifecycle(servers);
 
     yield* spawn(function* () {
       for (state of yield* each(states)) {
@@ -68,87 +61,3 @@ export interface State {
   notify: RPCEndpoint["notify"];
   request: RPCEndpoint["request"];
 }
-
-function uninitialized(
-  servers: RPCEndpoint[],
-  transition: (state: State) => Operation<void>,
-): State {
-  return {
-    *notify() {},
-    *request<T>(params: RequestParams): Operation<T> {
-      let [method] = params;
-      if (method !== "initialize") {
-        yield* responseError(
-          ErrorCodes.ServerNotInitialized,
-          `server not initialized`,
-        );
-      }
-      let agents = yield* all(servers.map((server) =>
-        call(function* () {
-          let initialization = yield* server.request<InitializeResult>(
-            params,
-          );
-          let { capabilities } = initialization;
-          return {
-            ...server,
-            initialization,
-            capabilities,
-          } as LSPAgent;
-        })
-      ));
-
-      yield* transition(initialized(agents, transition));
-
-      return merge.capabilities(agents) as T;
-    },
-  };
-}
-
-function initialized(
-  agents: LSPAgent[],
-  transition: (state: State) => Operation<void>,
-): State {
-  return {
-    *notify(params) {
-      // TODO: only forward notifications to interested agents
-      for (let agent of agents) {
-        yield* agent.notify(params);
-      }
-    },
-    *request(params) {
-      let [first] = agents;
-      let [method] = params;
-      if (method === "initialize") {
-        yield* responseError(
-          ErrorCodes.InvalidRequest,
-          `initialize invoked twice`,
-        );
-      } else if (method === "shutdown") {
-        yield* transition(shutdown);
-        for (let agent of agents) {
-          yield* agent.request(params);
-        }
-        return cast(null);
-      } else if (!first) {
-        throw yield* responseError(
-          ErrorCodes.InternalError,
-          `no lsps to make requests`,
-        );
-      }
-
-      return yield* first.request(params);
-    },
-  };
-}
-
-const shutdown: State = {
-  *notify() {},
-  *request() {
-    return yield* responseError(
-      ErrorCodes.InvalidRequest,
-      `server is shut down`,
-    );
-  },
-};
-
-const cast = <T>(value: unknown) => value as T;