swls-wasm 0.3.1 → 0.3.2-alpha.2

package/client.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Creates a Web Worker running the swls language server (browser/web hosts).
+ *
+ * The returned worker speaks whole JSON-RPC messages over `postMessage` (no
+ * `Content-Length` framing) and emits a `{ method: "swls/ready" }` notification
+ * once the wasm has finished initializing.
+ *
+ * @param options Extra worker options; `type` is always `"module"`.
+ */
+export function createSwlsWorker(options?: Omit<WorkerOptions, "type">): Worker;

package/client.js

@@ -0,0 +1,21 @@
+/**
+ * Creates a Web Worker running the swls language server (browser/web hosts).
+ *
+ * The returned worker speaks whole JSON-RPC messages over `postMessage` (no
+ * `Content-Length` framing) and emits a `{ method: "swls/ready" }` notification
+ * once the wasm has finished initializing.
+ *
+ * Kept in its own entry (`swls-wasm/client`) rather than the package root so
+ * that Node/bundler consumers importing `swls-wasm` never pull in a nested
+ * `Worker`/wasm chunk they don't use.
+ *
+ * @param {WorkerOptions} [options] Extra worker options; `type` is always
+ *   `"module"`. (Kept after the spread so bundlers can statically read `type`.)
+ * @returns {Worker}
+ */
+export function createSwlsWorker(options) {
+  return new Worker(new URL("./worker.js", import.meta.url), {
+    ...options,
+    type: "module",
+  });
+}

package/index.d.ts

@@ -0,0 +1,2 @@
+export { default, initSync, WasmLsp, start_wasm_lsp } from "./swls_wasm.js";
+export { createSwlsServer } from "./pump.js";

package/index.js

@@ -0,0 +1,2 @@
+export { default, initSync, WasmLsp, start_wasm_lsp } from "./swls_wasm.js";
+export { createSwlsServer } from "./pump.js";

package/package.json

@@ -4,17 +4,40 @@
   "collaborators": [
     "ajuvercr <arthur.vercruysse@outlook.com>"
   ],
-  "version": "0.3.1",
+  "version": "0.3.2-alpha.2",
   "files": [
     "swls_wasm_bg.wasm",
     "swls_wasm.js",
-    "swls_wasm_bg.js",
-    "swls_wasm.d.ts"
+    "swls_wasm.d.ts",
+    "index.js",
+    "index.d.ts",
+    "pump.js",
+    "pump.d.ts",
+    "worker.js",
+    "client.js",
+    "client.d.ts"
   ],
-  "main": "swls_wasm.js",
-  "types": "swls_wasm.d.ts",
+  "main": "index.js",
+  "types": "index.d.ts",
   "sideEffects": [
-    "./swls_wasm.js",
-    "./snippets/*"
-  ]
-}
+    "./worker.js"
+  ],
+  "module": "index.js",
+  "exports": {
+    ".": {
+      "types": "./index.d.ts",
+      "default": "./index.js"
+    },
+    "./client": {
+      "types": "./client.d.ts",
+      "default": "./client.js"
+    },
+    "./worker": "./worker.js",
+    "./swls_wasm.js": {
+      "types": "./swls_wasm.d.ts",
+      "default": "./swls_wasm.js"
+    },
+    "./swls_wasm_bg.wasm": "./swls_wasm_bg.wasm",
+    "./package.json": "./package.json"
+  }
+}

package/pump.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Boots the swls wasm LSP and wires it to a host transport.
+ *
+ * Host-agnostic: the caller decides how outgoing messages are delivered
+ * (`post`) and feeds incoming messages into the returned function. Both
+ * directions exchange whole JSON-RPC messages with no `Content-Length`
+ * framing — `post` receives already-parsed objects, and the returned feed
+ * accepts either a parsed object or a raw JSON string.
+ *
+ * @param post Called with each outgoing JSON-RPC message (already parsed).
+ * @param options.debug The server's debug-log sink.
+ * @param options.wasm Overrides the module/URL forwarded to the wasm `init()`
+ *   (defaults to the sibling `swls_wasm_bg.wasm`); pass it when the host cannot
+ *   fetch that sibling itself (e.g. Node, which can't `fetch` a `file://` URL).
+ * @returns Resolves once wasm is initialized to a function that feeds one
+ *   incoming message (object or string) to the server.
+ */
+export function createSwlsServer(
+  post: (message: unknown) => void,
+  options?: {
+    debug?: (message: string) => void;
+    wasm?: string | URL | Request | BufferSource | WebAssembly.Module;
+  },
+): Promise<(data: unknown) => void>;

package/pump.js

@@ -0,0 +1,36 @@
+import init, { WasmLsp } from "./swls_wasm.js";
+
+/**
+ * Boots the swls wasm LSP and wires it to a host transport.
+ *
+ * Host-agnostic: the caller decides how outgoing messages are delivered
+ * (`post`) and feeds incoming messages into the returned function. Both
+ * directions exchange whole JSON-RPC messages with no `Content-Length`
+ * framing — `post` receives already-parsed objects, and the returned feed
+ * accepts either a parsed object or a raw JSON string.
+ *
+ * Used directly by non-DOM hosts (e.g. a VS Code `worker_threads` server or
+ * the web-extension host); browser consumers get this wrapped in a Worker via
+ * {@link createSwlsWorker} (see `swls-wasm/client`).
+ *
+ * @param {(message: unknown) => void} post
+ *   Called with each outgoing JSON-RPC message (already parsed).
+ * @param {{
+ *   debug?: (message: string) => void,
+ *   wasm?: string | URL | Request | BufferSource | WebAssembly.Module,
+ * }} [options]
+ *   `debug` is the server's debug-log sink. `wasm` overrides the module/URL
+ *   forwarded to the wasm `init()` (defaults to the sibling
+ *   `swls_wasm_bg.wasm`); pass it when the host cannot fetch that sibling
+ *   itself (e.g. Node, which can't `fetch` a `file://` URL).
+ * @returns {Promise<(data: unknown) => void>}
+ *   Resolves once wasm is initialized to a function that feeds one incoming
+ *   message (object or string) to the server.
+ */
+export async function createSwlsServer(post, options = {}) {
+  const { debug, wasm } = options;
+  await init(wasm === undefined ? undefined : { module_or_path: wasm });
+  const lsp = new WasmLsp((message) => post(JSON.parse(message)), debug);
+  return (data) =>
+    lsp.send(typeof data === "string" ? data : JSON.stringify(data));
+}

package/swls_wasm.d.ts

@@ -3,6 +3,12 @@
 
 /**
  * A self-contained WASM LSP instance that JS can create.
+ *
+ * Both directions exchange whole JSON-RPC messages (no `Content-Length` framing):
+ * JS calls [`WasmLsp::send`] with a raw message string, and the `post_message_cb`
+ * receives raw message strings. Inbound requests/notifications are processed in
+ * order by a single consumer task; responses to server-initiated requests are
+ * resolved inline so they never queue behind an in-flight handler.
  */
 export class WasmLsp {
     free(): void;
@@ -12,9 +18,52 @@ export class WasmLsp {
      */
     constructor(post_message_cb: Function, debug_cb?: Function | null);
     /**
-     * Send a message from JS → LSP.
+     * Send a message from JS → LSP. `msg` is a raw JSON-RPC message.
      */
     send(msg: string): void;
 }
 
 export function start_wasm_lsp(): Promise<void>;
+
+export type InitInput = RequestInfo | URL | Response | BufferSource | WebAssembly.Module;
+
+export interface InitOutput {
+    readonly memory: WebAssembly.Memory;
+    readonly __wbg_wasmlsp_free: (a: number, b: number) => void;
+    readonly start_wasm_lsp: () => void;
+    readonly wasmlsp_new: (a: any, b: number) => number;
+    readonly wasmlsp_send: (a: number, b: number, c: number) => void;
+    readonly wasm_bindgen__convert__closures_____invoke__h5d8169a9c6a0716a: (a: number, b: number, c: any) => [number, number];
+    readonly wasm_bindgen__convert__closures_____invoke__h0a08a9b6706aa208: (a: number, b: number, c: any, d: any) => void;
+    readonly __wbindgen_malloc: (a: number, b: number) => number;
+    readonly __wbindgen_realloc: (a: number, b: number, c: number, d: number) => number;
+    readonly __wbindgen_exn_store: (a: number) => void;
+    readonly __externref_table_alloc: () => number;
+    readonly __wbindgen_externrefs: WebAssembly.Table;
+    readonly __wbindgen_free: (a: number, b: number, c: number) => void;
+    readonly __wbindgen_destroy_closure: (a: number, b: number) => void;
+    readonly __externref_table_dealloc: (a: number) => void;
+    readonly __wbindgen_start: () => void;
+}
+
+export type SyncInitInput = BufferSource | WebAssembly.Module;
+
+/**
+ * Instantiates the given `module`, which can either be bytes or
+ * a precompiled `WebAssembly.Module`.
+ *
+ * @param {{ module: SyncInitInput }} module - Passing `SyncInitInput` directly is deprecated.
+ *
+ * @returns {InitOutput}
+ */
+export function initSync(module: { module: SyncInitInput } | SyncInitInput): InitOutput;
+
+/**
+ * If `module_or_path` is {RequestInfo} or {URL}, makes a request and
+ * for everything else, calls `WebAssembly.instantiate` directly.
+ *
+ * @param {{ module_or_path: InitInput | Promise<InitInput> }} module_or_path - Passing `InitInput` directly is deprecated.
+ *
+ * @returns {Promise<InitOutput>}
+ */
+export default function __wbg_init (module_or_path?: { module_or_path: InitInput | Promise<InitInput> } | InitInput | Promise<InitInput>): Promise<InitOutput>;