@nbt-dev/components 0.0.5

package/dist/chunk-S7VBQE6Y.js

@@ -0,0 +1,636 @@
+"use client";
+
+// src/editor/nbt-editor.tsx
+import React from "react";
+import { EditorState } from "@codemirror/state";
+import {
+  EditorView as EditorView2,
+  keymap as keymap2,
+  lineNumbers,
+  drawSelection,
+  highlightActiveLine
+} from "@codemirror/view";
+import {
+  defaultKeymap,
+  history,
+  historyKeymap,
+  indentWithTab
+} from "@codemirror/commands";
+import {
+  syntaxHighlighting,
+  defaultHighlightStyle,
+  bracketMatching
+} from "@codemirror/language";
+import { lintGutter } from "@codemirror/lint";
+import { searchKeymap } from "@codemirror/search";
+import { completionKeymap, closeBrackets } from "@codemirror/autocomplete";
+
+// src/editor/nbt-language.ts
+import {
+  StreamLanguage,
+  LanguageSupport,
+  indentUnit
+} from "@codemirror/language";
+var KEYWORDS = /* @__PURE__ */ new Set([
+  "entity",
+  "enum",
+  "struct",
+  "const",
+  "export",
+  "extends",
+  "fn",
+  "on",
+  "action",
+  "activity",
+  "task",
+  "variant",
+  "workflow",
+  "command",
+  "middleware",
+  "schedule",
+  "every",
+  "jai",
+  "migration",
+  "test",
+  "mock",
+  "assert",
+  "cartridge",
+  "service",
+  "component",
+  "app",
+  "route",
+  "layout",
+  "import",
+  "from",
+  "if",
+  "elif",
+  "else",
+  "while",
+  "for",
+  "in",
+  "return",
+  "break",
+  "continue",
+  "delete",
+  "defer",
+  "print",
+  "sleep",
+  "fail"
+]);
+var TYPES = /* @__PURE__ */ new Set([
+  "string",
+  "bool",
+  "ulid",
+  "document",
+  "dict",
+  "blob",
+  "DateTime",
+  "u8",
+  "u16",
+  "u32",
+  "u64",
+  "s8",
+  "s16",
+  "s32",
+  "s64",
+  "int",
+  "integer",
+  "float",
+  "float64",
+  "f32",
+  "f64",
+  "double",
+  "time",
+  "bytes",
+  "any",
+  "name",
+  "ref"
+]);
+function eatSingleLineString(stream, quote) {
+  while (!stream.eol()) {
+    if (stream.next() === quote) break;
+  }
+  return "string";
+}
+var nbtParser = {
+  name: "nbt",
+  startState: () => ({ tripleString: false }),
+  token(stream, state) {
+    if (state.tripleString) {
+      while (!stream.eol()) {
+        if (stream.match('"""')) {
+          state.tripleString = false;
+          return "string";
+        }
+        stream.next();
+      }
+      return "string";
+    }
+    if (stream.eatSpace()) return null;
+    const ch = stream.peek();
+    if (ch == null) return null;
+    if (ch === "#") {
+      stream.skipToEnd();
+      return "comment";
+    }
+    if (stream.match('"""')) {
+      state.tripleString = true;
+      while (!stream.eol()) {
+        if (stream.match('"""')) {
+          state.tripleString = false;
+          return "string";
+        }
+        stream.next();
+      }
+      return "string";
+    }
+    if (ch === '"') {
+      stream.next();
+      return eatSingleLineString(stream, '"');
+    }
+    if (ch === "'") {
+      const before = stream.string.charAt(stream.pos - 1);
+      if (!/[A-Za-z0-9_]/.test(before)) {
+        stream.next();
+        return eatSingleLineString(stream, "'");
+      }
+      stream.next();
+      return null;
+    }
+    if (ch === "f" && stream.string.charAt(stream.pos + 1) === '"') {
+      stream.next();
+      stream.next();
+      return eatSingleLineString(stream, '"');
+    }
+    if (ch === "@") {
+      stream.next();
+      stream.eat("@");
+      stream.eatWhile(/[A-Za-z0-9_]/);
+      return "meta";
+    }
+    if (/\d/.test(ch)) {
+      stream.match(/^\d+(\.\d+)?/);
+      return "number";
+    }
+    if (/[A-Za-z_]/.test(ch)) {
+      stream.eatWhile(/[A-Za-z0-9_]/);
+      const word = stream.current();
+      if (word === "true" || word === "false") return "atom";
+      if (KEYWORDS.has(word)) return "keyword";
+      if (TYPES.has(word)) return "typeName";
+      if (/^[A-Z]/.test(word)) return "typeName";
+      return "variableName";
+    }
+    if (/[+\-*/=<>!&|?.,:;]/.test(ch)) {
+      stream.next();
+      stream.eatWhile(/[+\-*/=<>!&|.]/);
+      return "operator";
+    }
+    stream.next();
+    return null;
+  },
+  languageData: {
+    commentTokens: { line: "#" }
+  }
+};
+var nbtLanguage = StreamLanguage.define(nbtParser);
+function nbtLanguageSupport() {
+  return new LanguageSupport(nbtLanguage, [indentUnit.of("  ")]);
+}
+
+// src/editor/lsp-extensions.ts
+import {
+  ViewPlugin,
+  hoverTooltip,
+  keymap
+} from "@codemirror/view";
+import {
+  autocompletion
+} from "@codemirror/autocomplete";
+import { setDiagnostics } from "@codemirror/lint";
+function toLspPos(doc, offset) {
+  const line = doc.lineAt(offset);
+  return { line: line.number - 1, character: offset - line.from };
+}
+function fromLspPos(doc, pos) {
+  const lineNo = Math.min(Math.max(pos.line + 1, 1), doc.lines);
+  const line = doc.line(lineNo);
+  return Math.min(line.from + Math.max(pos.character, 0), line.to);
+}
+function toCmDiagnostics(doc, diags) {
+  return diags.map((d) => {
+    const from = fromLspPos(doc, d.range.start);
+    let to = fromLspPos(doc, d.range.end);
+    if (to <= from) to = Math.min(from + 1, doc.length);
+    const severity = d.severity === 2 ? "warning" : d.severity === 3 || d.severity === 4 ? "info" : "error";
+    return { from, to, severity, message: d.message, source: d.source ?? "nbt" };
+  });
+}
+function completionType(kind) {
+  switch (kind) {
+    case 3:
+      return "function";
+    case 5:
+      return "property";
+    case 13:
+      return "enum";
+    case 14:
+      return "keyword";
+    case 22:
+      return "class";
+    default:
+      return "variable";
+  }
+}
+function lspExtensions(client, uri, onGotoDefinition) {
+  const syncPlugin = ViewPlugin.fromClass(
+    class {
+      constructor(view) {
+        this.view = view;
+        this.timer = null;
+        client.didOpen(uri, view.state.doc.toString());
+        this.unsubscribe = client.onDiagnostics(uri, (diags) => {
+          const cm = toCmDiagnostics(this.view.state.doc, diags);
+          this.view.dispatch(setDiagnostics(this.view.state, cm));
+        });
+      }
+      update(u) {
+        if (!u.docChanged) return;
+        if (this.timer) clearTimeout(this.timer);
+        this.timer = setTimeout(() => {
+          this.timer = null;
+          client.didChange(uri, this.view.state.doc.toString());
+        }, 200);
+      }
+      destroy() {
+        if (this.timer) {
+          clearTimeout(this.timer);
+          client.didChange(uri, this.view.state.doc.toString());
+        }
+        this.unsubscribe();
+      }
+    }
+  );
+  const completionSource = async (ctx) => {
+    const word = ctx.matchBefore(/\w*/);
+    if (!word) return null;
+    if (word.from === word.to && !ctx.explicit) {
+      const before = ctx.state.doc.sliceString(Math.max(0, ctx.pos - 1), ctx.pos);
+      if (before !== "." && before !== ":" && before !== '"') return null;
+    }
+    client.didChange(uri, ctx.state.doc.toString());
+    let result;
+    try {
+      result = await client.completion(uri, toLspPos(ctx.state.doc, ctx.pos));
+    } catch {
+      return null;
+    }
+    const items = Array.isArray(result) ? result : result?.items ?? [];
+    if (items.length === 0) return null;
+    return {
+      from: word.from,
+      options: items.map((it) => ({
+        label: it.label,
+        type: completionType(it.kind),
+        detail: it.detail
+      }))
+    };
+  };
+  const hover = hoverTooltip(async (view, pos) => {
+    let result;
+    try {
+      result = await client.hover(uri, toLspPos(view.state.doc, pos));
+    } catch {
+      return null;
+    }
+    const value = result?.contents?.value;
+    if (!value) return null;
+    return {
+      pos,
+      create: () => {
+        const dom = document.createElement("pre");
+        dom.className = "nbt-hover-tooltip";
+        dom.style.cssText = "margin:0;padding:6px 8px;max-width:480px;white-space:pre-wrap;font-size:11px;";
+        dom.textContent = value.replace(/```\w*\n?/g, "");
+        return { dom };
+      }
+    };
+  });
+  const gotoDef = keymap.of([
+    {
+      key: "F12",
+      run: (view) => {
+        const pos = toLspPos(view.state.doc, view.state.selection.main.head);
+        client.definition(uri, pos).then((result) => {
+          const loc = Array.isArray(result) ? result[0] ?? null : result;
+          if (!loc?.uri) return;
+          if (loc.uri === uri) {
+            const off = fromLspPos(view.state.doc, loc.range.start);
+            view.dispatch({
+              selection: { anchor: off },
+              scrollIntoView: true
+            });
+          } else {
+            onGotoDefinition?.(loc.uri, loc.range.start.line);
+          }
+        }).catch(() => {
+        });
+        return true;
+      }
+    }
+  ]);
+  return [
+    syncPlugin,
+    autocompletion({ override: [completionSource] }),
+    hover,
+    gotoDef
+  ];
+}
+
+// src/editor/nbt-editor.tsx
+import { jsx } from "react/jsx-runtime";
+var nbtTheme = EditorView2.theme(
+  {
+    "&": {
+      height: "100%",
+      fontSize: "12px",
+      backgroundColor: "var(--background)",
+      color: "var(--foreground)"
+    },
+    ".cm-content": { fontFamily: "ui-monospace, monospace" },
+    ".cm-gutters": {
+      backgroundColor: "var(--background)",
+      color: "var(--muted-foreground)",
+      borderRight: "1px solid var(--border)"
+    },
+    ".cm-activeLine": { backgroundColor: "color-mix(in srgb, var(--accent) 35%, transparent)" },
+    "&.cm-focused": { outline: "none" },
+    ".cm-tooltip": {
+      backgroundColor: "var(--popover)",
+      color: "var(--popover-foreground)",
+      border: "1px solid var(--border)"
+    }
+  },
+  { dark: true }
+);
+var NbtEditor = ({
+  uri,
+  value,
+  readOnly = false,
+  lsp,
+  onChange,
+  onSave,
+  onGotoDefinition
+}) => {
+  const hostRef = React.useRef(null);
+  const viewRef = React.useRef(null);
+  const onChangeRef = React.useRef(onChange);
+  onChangeRef.current = onChange;
+  const onSaveRef = React.useRef(onSave);
+  onSaveRef.current = onSave;
+  const onGotoRef = React.useRef(onGotoDefinition);
+  onGotoRef.current = onGotoDefinition;
+  React.useEffect(() => {
+    const host = hostRef.current;
+    if (!host) return;
+    const extensions = [
+      lineNumbers(),
+      history(),
+      drawSelection(),
+      highlightActiveLine(),
+      bracketMatching(),
+      closeBrackets(),
+      lintGutter(),
+      syntaxHighlighting(defaultHighlightStyle, { fallback: true }),
+      nbtLanguageSupport(),
+      nbtTheme,
+      keymap2.of([
+        {
+          key: "Mod-s",
+          run: (view2) => {
+            onSaveRef.current?.(view2.state.doc.toString());
+            return true;
+          }
+        },
+        ...defaultKeymap,
+        ...historyKeymap,
+        ...searchKeymap,
+        ...completionKeymap,
+        indentWithTab
+      ]),
+      EditorView2.updateListener.of((u) => {
+        if (u.docChanged) onChangeRef.current?.(u.state.doc.toString());
+      }),
+      EditorState.readOnly.of(readOnly)
+    ];
+    if (lsp && !readOnly) {
+      extensions.push(
+        lspExtensions(lsp, uri, (defUri, line) => onGotoRef.current?.(defUri, line))
+      );
+    }
+    const view = new EditorView2({
+      state: EditorState.create({ doc: value, extensions }),
+      parent: host
+    });
+    viewRef.current = view;
+    return () => {
+      view.destroy();
+      viewRef.current = null;
+    };
+  }, [uri, readOnly, lsp]);
+  return /* @__PURE__ */ jsx("div", { ref: hostRef, className: "h-full min-h-0 overflow-hidden" });
+};
+
+// src/editor/lsp-client.ts
+var NbtLspClient = class {
+  constructor(url) {
+    this.rootUri = null;
+    this.ws = null;
+    this.nextId = 1;
+    this.pending = /* @__PURE__ */ new Map();
+    this.diagHandlers = /* @__PURE__ */ new Map();
+    // Open buffers, kept for replay across reconnects.
+    this.docs = /* @__PURE__ */ new Map();
+    this.ready = false;
+    this.queue = [];
+    this.closed = false;
+    this.retryMs = 500;
+    this.url = url;
+    this.connect();
+  }
+  dispose() {
+    this.closed = true;
+    this.ws?.close();
+    this.pending.forEach((p) => p.reject(new Error("lsp client disposed")));
+    this.pending.clear();
+  }
+  connect() {
+    if (this.closed) return;
+    const ws = new WebSocket(this.url);
+    this.ws = ws;
+    ws.onopen = () => {
+      this.retryMs = 500;
+      if (this.rootUri) this.sendInitialize(this.rootUri);
+    };
+    ws.onmessage = (ev) => {
+      if (typeof ev.data !== "string") return;
+      this.onMessage(ev.data);
+    };
+    ws.onclose = () => {
+      this.ready = false;
+      this.ws = null;
+      for (const p of this.pending.values())
+        p.reject(new Error("lsp connection closed"));
+      this.pending.clear();
+      if (!this.closed) {
+        setTimeout(() => this.connect(), this.retryMs);
+        this.retryMs = Math.min(this.retryMs * 2, 1e4);
+      }
+    };
+  }
+  // Called once by the host with file://<projectRoot>; also re-sent after every
+  // reconnect, followed by didOpen replays for tracked buffers.
+  initialize(rootUri) {
+    this.rootUri = rootUri;
+    if (this.ws?.readyState === WebSocket.OPEN) this.sendInitialize(rootUri);
+  }
+  sendInitialize(rootUri) {
+    const id = this.nextId++;
+    this.pending.set(id, {
+      resolve: () => {
+        this.sendRaw({ jsonrpc: "2.0", method: "initialized", params: {} });
+        this.ready = true;
+        for (const [uri, d] of this.docs) {
+          this.sendRaw({
+            jsonrpc: "2.0",
+            method: "textDocument/didOpen",
+            params: {
+              textDocument: {
+                uri,
+                languageId: "nbt",
+                version: d.version,
+                text: d.text
+              }
+            }
+          });
+        }
+        const q = this.queue;
+        this.queue = [];
+        for (const m of q) this.ws?.send(m);
+      },
+      reject: () => {
+      }
+    });
+    this.ws?.send(
+      JSON.stringify({
+        jsonrpc: "2.0",
+        id,
+        method: "initialize",
+        params: { rootUri }
+      })
+    );
+  }
+  sendRaw(msg) {
+    const s = JSON.stringify(msg);
+    if (this.ready && this.ws?.readyState === WebSocket.OPEN) this.ws.send(s);
+    else this.queue.push(s);
+  }
+  onMessage(data) {
+    let msg;
+    try {
+      msg = JSON.parse(data);
+    } catch {
+      return;
+    }
+    if (msg.id != null && (msg.result !== void 0 || msg.error)) {
+      const p = this.pending.get(msg.id);
+      if (!p) return;
+      this.pending.delete(msg.id);
+      if (msg.error) p.reject(new Error(msg.error.message ?? "lsp error"));
+      else p.resolve(msg.result);
+      return;
+    }
+    if (msg.method === "textDocument/publishDiagnostics") {
+      const uri = msg.params?.uri;
+      const handler = this.diagHandlers.get(uri);
+      if (handler) handler(msg.params?.diagnostics ?? []);
+    }
+  }
+  request(method, params) {
+    const id = this.nextId++;
+    const p = new Promise((resolve, reject) => {
+      this.pending.set(id, { resolve, reject });
+    });
+    this.sendRaw({ jsonrpc: "2.0", id, method, params });
+    return p;
+  }
+  onDiagnostics(uri, handler) {
+    this.diagHandlers.set(uri, handler);
+    return () => {
+      if (this.diagHandlers.get(uri) === handler) this.diagHandlers.delete(uri);
+    };
+  }
+  didOpen(uri, text) {
+    const existing = this.docs.get(uri);
+    if (existing) {
+      this.didChange(uri, text);
+      return;
+    }
+    this.docs.set(uri, { text, version: 1 });
+    this.sendRaw({
+      jsonrpc: "2.0",
+      method: "textDocument/didOpen",
+      params: { textDocument: { uri, languageId: "nbt", version: 1, text } }
+    });
+  }
+  didChange(uri, text) {
+    const d = this.docs.get(uri);
+    if (!d) return this.didOpen(uri, text);
+    if (d.text === text) return;
+    d.text = text;
+    d.version += 1;
+    this.sendRaw({
+      jsonrpc: "2.0",
+      method: "textDocument/didChange",
+      params: {
+        textDocument: { uri, version: d.version },
+        contentChanges: [{ text }]
+      }
+    });
+  }
+  didClose(uri) {
+    if (!this.docs.delete(uri)) return;
+    this.sendRaw({
+      jsonrpc: "2.0",
+      method: "textDocument/didClose",
+      params: { textDocument: { uri } }
+    });
+  }
+  completion(uri, pos) {
+    return this.request("textDocument/completion", {
+      textDocument: { uri },
+      position: pos
+    });
+  }
+  hover(uri, pos) {
+    return this.request("textDocument/hover", {
+      textDocument: { uri },
+      position: pos
+    });
+  }
+  definition(uri, pos) {
+    return this.request("textDocument/definition", {
+      textDocument: { uri },
+      position: pos
+    });
+  }
+};
+
+export {
+  nbtLanguage,
+  nbtLanguageSupport,
+  lspExtensions,
+  NbtEditor,
+  NbtLspClient
+};
+//# sourceMappingURL=chunk-S7VBQE6Y.js.map