@vedivad/typst-web-service 0.7.11 → 0.8.0

package/README.md

@@ -27,6 +27,9 @@ if (result.vector) {
   document.querySelector("#preview")!.innerHTML = svg;
 }
 
+// result.diagnostics are returned in deterministic order
+// (path, start position, end position, message)
+
 // Multi-file
 const result = await compiler.compile({
   "/main.typ": '#import "template.typ": greet\n#greet("World")',
@@ -63,7 +66,7 @@ Config options ([typstyle docs](https://github.com/typstyle-rs/typstyle)):
 | `reorder_import_items`    | `boolean` | --      | Sort import items alphabetically    |
 | `wrap_text`               | `boolean` | --      | Wrap text to fit within `max_width` |
 
-## LSP analysis with tinymist
+## Completion and hover with tinymist
 
 `TypstAnalyzer` runs a [tinymist](https://github.com/Myriad-Dreamin/tinymist) language server in a Web Worker. The `wasmUrl` option must point to the `tinymist_bg.wasm` binary from the `tinymist-web` package.
 
@@ -73,25 +76,29 @@ import tinymistWasmUrl from "tinymist-web/pkg/tinymist_bg.wasm?url";
 
 const analyzer = await TypstAnalyzer.create({ wasmUrl: tinymistWasmUrl });
 
-analyzer.onDiagnostics((uri, diagnostics) => {
-  console.log(uri, diagnostics);
-});
-
 await analyzer.didChange("untitled:project/main.typ", source);
-const completions = await analyzer.completion("untitled:project/main.typ", line, character);
-const hover = await analyzer.hover("untitled:project/main.typ", line, character);
+const completions = await analyzer.completion(
+  "untitled:project/main.typ",
+  line,
+  character,
+);
+const hover = await analyzer.hover(
+  "untitled:project/main.typ",
+  line,
+  character,
+);
 
 analyzer.destroy();
 ```
 
 ## Service classes
 
-| Class            | Runs on     | WASM loading            | Purpose                                                   |
-| ---------------- | ----------- | ----------------------- | --------------------------------------------------------- |
+| Class            | Runs on     | WASM loading            | Purpose                                                    |
+| ---------------- | ----------- | ----------------------- | ---------------------------------------------------------- |
 | `TypstCompiler`  | Web Worker  | CDN (automatic)         | `compile()` -> diagnostics + vector, `compilePdf()` -> PDF |
 | `TypstRenderer`  | Main thread | CDN (automatic)         | `renderSvg(vector)` -> SVG string                          |
-| `TypstFormatter` | Main thread | Bundler (static import) | `format(source)`, `formatRange(source, start, end)`       |
-| `TypstAnalyzer`  | Web Worker  | User-provided `wasmUrl` | LSP diagnostics, completion, hover via tinymist            |
+| `TypstFormatter` | Main thread | Bundler (static import) | `format(source)`, `formatRange(source, start, end)`        |
+| `TypstAnalyzer`  | Web Worker  | User-provided `wasmUrl` | Completion + hover via tinymist                            |
 
 ## License
 

package/dist/analyzer-worker.js

@@ -1,3 +1,6 @@
+// src/analyzer-worker.ts
+import * as Comlink from "comlink";
+
 // ../../node_modules/.bun/tinymist-web@https+++github.com+Myriad-Dreamin+tinymist+releases+download+v0.14.10+tinymist-web.tar.gz/node_modules/tinymist-web/pkg/tinymist.js
 var wasm;
 function addToExternrefTable0(obj) {
@@ -911,168 +914,121 @@ async function __wbg_init(module_or_path) {
 }
 var tinymist_default = __wbg_init;
 
-// src/worker-utils.ts
-function postError(id, err) {
-  const message = err instanceof Error ? err.message : String(err);
-  self.postMessage({ type: "error", id, message });
-}
-
 // src/analyzer-worker.ts
-var server = null;
-var events = [];
-function normalizeUri(uri) {
-  return uri.startsWith("untitled:/") ? `untitled:${uri.slice("untitled:/".length)}` : uri;
-}
-function flushEvents() {
-  if (!server) return;
-  while (events.length > 0) {
-    for (const event of events.splice(0)) {
-      server.on_event(event);
-    }
+var AnalyzerWorker = class {
+  server = null;
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any -- events are opaque values from WASM
+  events = [];
+  ensureServer() {
+    if (!this.server) throw new Error("Analyzer not initialized");
+    return this.server;
   }
-}
-async function initServer(wasmUrl) {
-  await tinymist_default(wasmUrl);
-  server = new TinymistLanguageServer({
-    sendEvent: (event) => void events.push(event),
-    sendRequest({ id }) {
-      server.on_response({ id, result: null });
-    },
-    sendNotification: ({
-      method,
-      params
-    }) => {
-      if (method === "textDocument/publishDiagnostics") {
-        const { uri, diagnostics } = params;
-        self.postMessage({
-          type: "diagnostics",
-          uri: normalizeUri(uri),
-          diagnostics
-        });
-      }
-    },
-    resolveFn: () => void 0
-  });
-  const initResult = server.on_request("initialize", {
-    capabilities: {
-      textDocument: {
-        publishDiagnostics: { relatedInformation: true },
-        completion: { completionItem: { snippetSupport: true } },
-        hover: { contentFormat: ["markdown", "plaintext"] }
-      }
-    },
-    rootUri: "file:///"
-  });
-  if (initResult && typeof initResult === "object" && "then" in initResult) {
-    await initResult;
+  notifyDidOpen(uri, content) {
+    this.ensureServer().on_notification("textDocument/didOpen", {
+      textDocument: { uri, languageId: "typst", version: 1, text: content }
+    });
   }
-  flushEvents();
-  server.on_notification("initialized", {});
-  flushEvents();
-}
-self.onmessage = async (e) => {
-  const req = e.data;
-  if (req.type === "init") {
-    try {
-      await initServer(req.wasmUrl);
-      self.postMessage({
-        type: "ready",
-        id: req.id
-      });
-    } catch (err) {
-      postError(req.id, err);
-    }
-    return;
+  notifyDidClose(uri) {
+    this.ensureServer().on_notification("textDocument/didClose", {
+      textDocument: { uri }
+    });
   }
-  if (!server) {
-    postError(req.id, new Error("Analyzer not initialized"));
-    return;
+  notifyDidChange(uri, version, content) {
+    this.ensureServer().on_notification("textDocument/didChange", {
+      textDocument: { uri, version },
+      contentChanges: [{ text: content }]
+    });
   }
-  if (req.type === "didOpen") {
-    try {
-      server.on_notification("textDocument/didOpen", {
+  flushEvents() {
+    if (!this.server) return;
+    while (this.events.length > 0) {
+      for (const event of this.events.splice(0)) {
+        this.server.on_event(event);
+      }
+    }
+  }
+  async init(wasmUrl) {
+    await tinymist_default({ module_or_path: wasmUrl });
+    this.server = new TinymistLanguageServer({
+      sendEvent: (event) => {
+        this.events.push(event);
+      },
+      sendRequest: ({
+        id
+      }) => {
+        this.server.on_response({ id, result: null });
+      },
+      sendNotification: () => {
+      },
+      resolveFn: () => void 0
+    });
+    const initResult = this.server.on_request("initialize", {
+      capabilities: {
         textDocument: {
-          uri: req.uri,
-          languageId: "typst",
-          version: 1,
-          text: req.content
+          completion: { completionItem: { snippetSupport: true } },
+          hover: { contentFormat: ["markdown", "plaintext"] }
         }
-      });
-      flushEvents();
-      self.postMessage({ type: "ack", id: req.id });
-    } catch (err) {
-      postError(req.id, err);
+      },
+      rootUri: "file:///"
+    });
+    if (initResult && typeof initResult === "object" && "then" in initResult) {
+      await initResult;
     }
-    return;
+    this.flushEvents();
+    this.server.on_notification("initialized", {});
+    this.flushEvents();
   }
-  if (req.type === "didClose") {
-    try {
-      server.on_notification("textDocument/didClose", {
-        textDocument: { uri: req.uri }
-      });
-      flushEvents();
-      self.postMessage({ type: "ack", id: req.id });
-    } catch (err) {
-      postError(req.id, err);
-    }
-    return;
+  async didOpen(uri, content) {
+    this.notifyDidOpen(uri, content);
+    this.flushEvents();
   }
-  if (req.type === "didChange") {
-    try {
-      server.on_notification("textDocument/didChange", {
-        textDocument: { uri: req.uri, version: req.version },
-        contentChanges: [{ text: req.content }]
-      });
-      flushEvents();
-      self.postMessage({ type: "ack", id: req.id });
-    } catch (err) {
-      postError(req.id, err);
-    }
-    return;
+  async didClose(uri) {
+    this.notifyDidClose(uri);
+    this.flushEvents();
   }
-  if (req.type === "completion") {
-    try {
-      const result = server.on_request("textDocument/completion", {
-        textDocument: { uri: req.uri },
-        position: { line: req.line, character: req.character }
-      });
-      const resolved = result && typeof result === "object" && "then" in result ? await result : result;
-      flushEvents();
-      self.postMessage({
-        type: "completionResult",
-        id: req.id,
-        result: resolved ?? null
-      });
-    } catch (err) {
-      postError(req.id, err);
+  async didChange(uri, version, content) {
+    this.notifyDidChange(uri, version, content);
+    this.flushEvents();
+  }
+  async didChangeMany(opens, changes) {
+    this.ensureServer();
+    for (const { uri, content } of opens) {
+      this.notifyDidOpen(uri, content);
+    }
+    for (const { uri, version, content } of changes) {
+      this.notifyDidChange(uri, version, content);
     }
-    return;
+    this.flushEvents();
   }
-  if (req.type === "hover") {
-    try {
-      const result = server.on_request("textDocument/hover", {
-        textDocument: { uri: req.uri },
-        position: { line: req.line, character: req.character }
-      });
-      const resolved = result && typeof result === "object" && "then" in result ? await result : result;
-      flushEvents();
-      self.postMessage({
-        type: "hoverResult",
-        id: req.id,
-        result: resolved ?? null
-      });
-    } catch (err) {
-      postError(req.id, err);
+  async didCloseMany(uris) {
+    this.ensureServer();
+    for (const uri of uris) {
+      this.notifyDidClose(uri);
     }
-    return;
+    this.flushEvents();
+  }
+  async completion(uri, line, character) {
+    const result = this.ensureServer().on_request("textDocument/completion", {
+      textDocument: { uri },
+      position: { line, character }
+    });
+    const resolved = result && typeof result === "object" && "then" in result ? await result : result;
+    this.flushEvents();
+    return resolved ?? null;
   }
-  if (req.type === "destroy") {
-    server.free();
-    server = null;
-    self.postMessage({
-      type: "destroyed",
-      id: req.id
+  async hover(uri, line, character) {
+    const result = this.ensureServer().on_request("textDocument/hover", {
+      textDocument: { uri },
+      position: { line, character }
     });
+    const resolved = result && typeof result === "object" && "then" in result ? await result : result;
+    this.flushEvents();
+    return resolved ?? null;
+  }
+  destroy() {
+    this.server?.free();
+    this.server = null;
   }
 };
+Comlink.expose(new AnalyzerWorker());
 //# sourceMappingURL=analyzer-worker.js.map