@xano/xanoscript-language-server 11.9.1 → 11.10.1

package/parser/multidoc.js

@@ -0,0 +1,273 @@
+import { lexDocument } from "../lexer/lexer.js";
+import { crossFileValidate } from "../workspace/crossFileValidator.js";
+import { WorkspaceIndex } from "../workspace/workspaceIndex.js";
+import { xanoscriptParser } from "./parser.js";
+import { validateVariables } from "./variableValidator.js";
+
+const SEPARATOR = "\n---\n";
+const SEPARATOR_LENGTH = 5;
+
+/**
+ * Find the segment that contains the given global offset.
+ * @param {Object} parserResult - The multidoc parser result (must have segments array)
+ * @param {number} offset - Global character offset in the full document
+ * @returns {{ segment: Object, localOffset: number } | null}
+ */
+export function findSegmentAtOffset(parserResult, offset) {
+  if (!parserResult?.segments) return null;
+
+  for (const segment of parserResult.segments) {
+    const segEnd = segment.globalOffset + segment.text.length;
+    if (offset >= segment.globalOffset && offset < segEnd) {
+      return {
+        segment,
+        localOffset: offset - segment.globalOffset,
+      };
+    }
+  }
+
+  // Offset might be at the very end of the last segment
+  const last = parserResult.segments[parserResult.segments.length - 1];
+  if (last && offset === last.globalOffset + last.text.length) {
+    return {
+      segment: last,
+      localOffset: offset - last.globalOffset,
+    };
+  }
+
+  return null;
+}
+
+/**
+ * Snapshot parser state into a plain object.
+ * Must be called immediately after xanoscriptParser() before parsing next segment,
+ * because the parser is a singleton that gets mutated on each call.
+ * @param {import('./base_parser.js').XanoBaseParser} parser
+ * @returns {Object} Plain object snapshot
+ */
+function snapshotParser(parser) {
+  return {
+    errors: parser.errors.map((e) => ({
+      message: e.message,
+      token: e.token
+        ? { startOffset: e.token.startOffset, endOffset: e.token.endOffset }
+        : null,
+    })),
+    warnings: parser.warnings.map((w) => ({
+      message: w.message,
+      token: w.token
+        ? { startOffset: w.token.startOffset, endOffset: w.token.endOffset }
+        : null,
+    })),
+    informations: parser.informations.map((i) => ({
+      message: i.message,
+      token: i.token
+        ? { startOffset: i.token.startOffset, endOffset: i.token.endOffset }
+        : null,
+    })),
+    hints: parser.hints.map((h) => ({
+      message: h.message,
+      token: h.token
+        ? { startOffset: h.token.startOffset, endOffset: h.token.endOffset }
+        : null,
+    })),
+    __symbolTable: parser.__symbolTable
+      ? {
+          input: { ...parser.__symbolTable.input },
+          var: { ...parser.__symbolTable.var },
+          auth: { ...parser.__symbolTable.auth },
+          env: { ...parser.__symbolTable.env },
+          references: parser.__symbolTable.references.map((r) => ({
+            ...r,
+            args: r.args ? { ...r.args } : undefined,
+            dataKeys: r.dataKeys ? [...r.dataKeys] : undefined,
+          })),
+          varDeclarations: parser.__symbolTable.varDeclarations.map((d) => ({
+            ...d,
+          })),
+        }
+      : null,
+  };
+}
+
+/**
+ * Apply a global offset to all position-bearing fields in a parser snapshot.
+ * @param {Object} snapshot - The parser state snapshot
+ * @param {number} globalOffset - The character offset to add
+ */
+function offsetResult(snapshot, globalOffset) {
+  if (globalOffset === 0) return;
+
+  const offsetToken = (token) => {
+    if (!token) return;
+    token.startOffset += globalOffset;
+    token.endOffset += globalOffset;
+  };
+
+  for (const err of snapshot.errors) offsetToken(err.token);
+  for (const warn of snapshot.warnings) offsetToken(warn.token);
+  for (const info of snapshot.informations) offsetToken(info.token);
+  for (const hint of snapshot.hints) offsetToken(hint.token);
+
+  if (!snapshot.__symbolTable) return;
+
+  for (const ref of snapshot.__symbolTable.references) {
+    ref.startOffset += globalOffset;
+    ref.endOffset += globalOffset;
+    if (ref.fieldNameStartOffset != null) {
+      ref.fieldNameStartOffset += globalOffset;
+      ref.fieldNameEndOffset += globalOffset;
+    }
+    if (ref.args) {
+      for (const arg of Object.values(ref.args)) {
+        if (arg && arg.startOffset != null) {
+          arg.startOffset += globalOffset;
+          arg.endOffset += globalOffset;
+        }
+      }
+    }
+    if (ref.dataKeys) {
+      for (const dk of ref.dataKeys) {
+        if (dk.startOffset != null) {
+          dk.startOffset += globalOffset;
+          dk.endOffset += globalOffset;
+        }
+      }
+    }
+  }
+
+  for (const decl of snapshot.__symbolTable.varDeclarations) {
+    if (decl.startOffset != null) {
+      decl.startOffset += globalOffset;
+      decl.endOffset += globalOffset;
+    }
+  }
+}
+
+/**
+ * Parse a multidoc or single-doc XanoScript text.
+ * Detects `\n---\n` separator. If absent, delegates to xanoscriptParser as-is.
+ * If present, splits, parses each segment, offsets positions, and merges results.
+ * @param {string} text - The full document text
+ * @returns {Object} Merged parser result
+ */
+export function multidocParser(text) {
+  if (!text.includes(SEPARATOR)) {
+    // Single document — delegate as-is
+    const parser = xanoscriptParser(text);
+    return snapshotParser(parser);
+  }
+
+  const segments = text.split(SEPARATOR);
+  const results = [];
+  let globalOffset = 0;
+
+  for (const segmentText of segments) {
+    const parser = xanoscriptParser(segmentText);
+    const snapshot = snapshotParser(parser);
+
+    // Variable validation with segment-local offsets and tokens
+    const segLexResult = lexDocument(segmentText);
+    if (snapshot.__symbolTable?.varDeclarations) {
+      const varResult = validateVariables(
+        snapshot.__symbolTable,
+        segLexResult.tokens,
+      );
+      for (const warning of varResult.warnings) {
+        snapshot.warnings.push({
+          message: warning.message,
+          token: {
+            startOffset: warning.startOffset,
+            endOffset: warning.endOffset,
+          },
+        });
+      }
+      for (const hint of varResult.hints) {
+        snapshot.hints.push({
+          message: hint.message,
+          token: {
+            startOffset: hint.startOffset,
+            endOffset: hint.endOffset,
+          },
+        });
+      }
+    }
+
+    // Save a copy of the segment's symbol table before offsetting (for workspace indexing and hover)
+    const segmentSymbolTable = snapshot.__symbolTable
+      ? { input: { ...snapshot.__symbolTable.input } }
+      : null;
+    // Deep-copy the snapshot before offsetResult mutates it (needed for hover providers)
+    const localSnapshot = JSON.parse(JSON.stringify(snapshot));
+    results.push({ snapshot, localSnapshot, segmentText, segmentSymbolTable, globalOffset });
+    globalOffset += segmentText.length + SEPARATOR_LENGTH;
+  }
+
+  // For now, merge without offsetting (next task)
+  const merged = {
+    errors: [],
+    warnings: [],
+    informations: [],
+    hints: [],
+    __symbolTable: {
+      input: {},
+      var: {},
+      auth: {},
+      env: {},
+      references: [],
+      varDeclarations: [],
+    },
+    isMultidoc: true,
+    segmentCount: segments.length,
+  };
+
+  for (const { snapshot, globalOffset } of results) {
+    offsetResult(snapshot, globalOffset);
+    merged.errors.push(...snapshot.errors);
+    merged.warnings.push(...snapshot.warnings);
+    merged.informations.push(...snapshot.informations);
+    merged.hints.push(...snapshot.hints);
+    if (snapshot.__symbolTable) {
+      merged.__symbolTable.references.push(
+        ...snapshot.__symbolTable.references,
+      );
+      merged.__symbolTable.varDeclarations.push(
+        ...snapshot.__symbolTable.varDeclarations,
+      );
+    }
+  }
+
+  // Build local workspace index from all segments for cross-reference validation
+  const localIndex = new WorkspaceIndex();
+  for (let i = 0; i < results.length; i++) {
+    const { segmentText, segmentSymbolTable } = results[i];
+    localIndex.addParsed(`multidoc#${i}`, segmentText, segmentSymbolTable);
+  }
+
+  // Validate references against local index only (self-contained)
+  if (merged.__symbolTable.references.length > 0) {
+    const crossRefWarnings = crossFileValidate(
+      merged.__symbolTable.references,
+      localIndex,
+    );
+    for (const warning of crossRefWarnings) {
+      merged.warnings.push({
+        message: warning.message,
+        token: {
+          startOffset: warning.startOffset,
+          endOffset: warning.endOffset,
+        },
+      });
+    }
+  }
+
+  // Store segment info for workspace indexing and hover support
+  merged.segments = results.map(({ segmentText, segmentSymbolTable, localSnapshot, globalOffset }) => ({
+    text: segmentText,
+    symbolTable: segmentSymbolTable,
+    parser: localSnapshot,
+    globalOffset,
+  }));
+
+  return merged;
+}