xq-lsp 1.0.0 → 1.2.0

package/src/runtimes/fonto/fonto.xq

@@ -0,0 +1,164 @@
+module namespace fonto = "http://www.fontoxml.com/functions";
+
+(:~
+ : Returns the common ancestor node of the current editor selection.
+ : @see https://documentation.fontoxml.com/latest/fonto-selection-common-ancestor-bc3ca1b4b8ef
+ :)
+declare function fonto:selection-common-ancestor() as node()? external;
+
+(:~
+ : Returns true if both edges of the global selection are within the given node or its descendants.
+ : @param $node The node to test.
+ : @see https://documentation.fontoxml.com/latest/fonto-selection-in-node-85e16ee4b6be
+ :)
+declare function fonto:selection-in-node($node as node()) as xs:boolean external;
+
+(:~
+ : Serializes a node as JsonML. Returns xs:string for text nodes, array() for other node types.
+ : @param $node The node to serialize.
+ : @see https://documentation.fontoxml.com/latest/fonto-serialize-as-jsonml-a1d656f6c5ca
+ :)
+declare function fonto:serialize-as-jsonml($node as node()) as item() external;
+
+(:~
+ : Returns the current hierarchy node ID, as set via the currentHierarchyNodeId option on evaluateXPath.
+ : May return the empty sequence in Hooks or mutations where all hierarchy nodes are considered current.
+ : @see https://documentation.fontoxml.com/latest/fonto-current-hierarchy-node-id-e69ed148e068
+ :)
+declare function fonto:current-hierarchy-node-id() as xs:string? external;
+
+(:~
+ : Returns the column index of a table cell. Returns the empty sequence if the node is not a cell.
+ : @param $node The table cell node.
+ : @see https://documentation.fontoxml.com/latest/fonto-get-column-index-ec839ee74c89
+ :)
+declare function fonto:get-column-index($node as node()) as xs:integer? external;
+
+(:~
+ : Returns true when the review route is open, false otherwise.
+ : @see https://documentation.fontoxml.com/latest/fonto-is-on-review-route-e29d1a0ba87f
+ :)
+declare function fonto:is-on-review-route() as xs:boolean external;
+
+(:~
+ : Returns true if the application is on the editor route and suggestion mode is active, false otherwise.
+ : @see https://documentation.fontoxml.com/latest/fonto-is-in-suggestion-mode-8aac7e957513
+ :)
+declare function fonto:is-in-suggestion-mode() as xs:boolean external;
+
+(:~
+ : Returns true if the given node is configured as removed.
+ : @param $node The node to check.
+ : @see https://documentation.fontoxml.com/latest/fonto-is-removed-a1bfbc4d67e7
+ :)
+declare function fonto:is-removed($node as node()) as xs:boolean external;
+
+(:~
+ : Returns true if the given node has the given DITA class, using the schema.
+ : @param $node The node to test.
+ : @param $ditaclass The DITA class string, e.g. "topic/p".
+ : @see https://documentation.fontoxml.com/latest/fonto-dita-class-9dd8240eb51f
+ :)
+declare function fonto:dita-class($node as node(), $ditaclass as xs:string) as xs:boolean external;
+
+(:~
+ : Returns the markup label of the given node, as configured via the markupLabel property in configureProperties.
+ : @param $node The node whose markup label to retrieve.
+ : @see https://documentation.fontoxml.com/latest/fonto-markup-label-94d77791388a
+ :)
+declare function fonto:markup-label($node as node()) as xs:string external;
+
+(:~
+ : Returns true if the given node is visualized as a block (e.g. configured as frame, structure, or block).
+ : Cannot be used in family configuration for the same node. Use fonto:in-inline-layout to check
+ : the expected layout context instead.
+ : @param $node The node to check.
+ : @see https://documentation.fontoxml.com/latest/fonto-block-layout-63c8bd99d28a
+ :)
+declare function fonto:block-layout($node as node()) as xs:boolean external;
+
+(:~
+ : Returns true if the given node should be rendered as inline, as determined by its parent's family.
+ : @param $node The node to check.
+ : @see https://documentation.fontoxml.com/latest/fonto-in-inline-layout-4073a50b4330
+ :)
+declare function fonto:in-inline-layout($node as node()) as xs:boolean external;
+
+(:~
+ : Returns a plain-text representation of the node's content, ignoring removed and detached descendants.
+ : Inserts newlines at block/inline boundaries and for break elements.
+ : @param $node The node to extract text from.
+ : @see https://documentation.fontoxml.com/latest/fonto-curated-text-in-node-4623872061c2
+ :)
+declare function fonto:curated-text-in-node($node as node()) as xs:string? external;
+
+(:~
+ : Returns a plain-text representation of the node's content with options (e.g. dfcs for bidi text).
+ : @param $node The node to extract text from.
+ : @param $options Options map (see CuratedTextOptions).
+ : @see https://documentation.fontoxml.com/latest/fonto-curated-text-in-node-4623872061c2
+ :)
+declare function fonto:curated-text-in-node($node as node(), $options as map(*)) as xs:string? external;
+
+(:~
+ : Returns a plain-text representation of a document range, ignoring removed and detached descendants.
+ : Returns the empty sequence for invalid or empty ranges.
+ : @param $startContainer The node containing the start of the range.
+ : @param $startOffset The offset within the start container.
+ : @param $endContainer The node containing the end of the range.
+ : @param $endOffset The offset within the end container.
+ : @see https://documentation.fontoxml.com/latest/fonto-curated-text-in-range-33986dbff804
+ :)
+declare function fonto:curated-text-in-range(
+	$startContainer as node(),
+	$startOffset as xs:numeric,
+	$endContainer as node(),
+	$endOffset as xs:numeric
+) as xs:string? external;
+
+(:~
+ : Returns a plain-text representation of a document range with options (e.g. dfcs for bidi text).
+ : Returns the empty sequence for invalid or empty ranges.
+ : @param $startContainer The node containing the start of the range.
+ : @param $startOffset The offset within the start container.
+ : @param $endContainer The node containing the end of the range.
+ : @param $endOffset The offset within the end container.
+ : @param $options Options map (see CuratedTextOptions).
+ : @see https://documentation.fontoxml.com/latest/fonto-curated-text-in-range-33986dbff804
+ :)
+declare function fonto:curated-text-in-range(
+	$startContainer as node(),
+	$startOffset as xs:numeric,
+	$endContainer as node(),
+	$endOffset as xs:numeric,
+	$options as map(*)
+) as xs:string? external;
+
+(:~
+ : Returns true if the document with the given remote document id is loaded.
+ : @param $remoteDocumentId The remote document id to check.
+ : @see https://documentation.fontoxml.com/latest/fonto-is-document-loaded-b22eba5424ed
+ :)
+declare function fonto:is-document-loaded($remoteDocumentId as xs:string) as xs:boolean external;
+
+(:~
+ : Returns true if the document with the given remote document id is in error state.
+ : @param $remoteDocumentId The remote document id to check.
+ : @see https://documentation.fontoxml.com/latest/fonto-is-document-errored-2b43985649f9
+ :)
+declare function fonto:is-document-errored($remoteDocumentId as xs:string) as xs:boolean external;
+
+(:~
+ : Returns the document node for the given remote document id if it is loaded, otherwise the empty sequence.
+ : @param $remoteDocumentId The remote document id.
+ : @see https://documentation.fontoxml.com/latest/fonto-document-fb5c19e1ad6d
+ :)
+declare function fonto:document($remoteDocumentId as xs:string?) as node()? external;
+
+(:~
+ : Returns a state map for the given remote document id (matching RemoteDocumentStateProperties),
+ : or the empty sequence if the document is not loaded.
+ : @param $remoteDocumentId The remote document id.
+ : @see https://documentation.fontoxml.com/latest/fonto-remote-document-state-03df124b223a
+ :)
+declare function fonto:remote-document-state($remoteDocumentId as xs:string) as map(*)? external;

package/src/runtimes.test.ts

@@ -0,0 +1,152 @@
+import { test, describe } from "node:test";
+import assert from "node:assert/strict";
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { fileURLToPath } from "node:url";
+import { analyze } from "./analyzer.ts";
+import { getCompletions } from "./completion.ts";
+import { formatQName } from "./types.ts";
+import { getRuntimeAnalyses } from "./runtimes.ts";
+
+const runtimesDir = path.join(path.dirname(fileURLToPath(import.meta.url)), "runtimes");
+
+describe("runtime defs: fonto", () => {
+	const fontoPath = path.join(runtimesDir, "fonto", "fonto.xq");
+	const fonto = analyze(fs.readFileSync(fontoPath, "utf-8"), "builtin:fonto");
+
+	test("fonto:selection-common-ancestor is present", () => {
+		assert.ok(
+			fonto.functions.map((f) => formatQName(f.qname)).includes("fonto:selection-common-ancestor"),
+			"fonto:selection-common-ancestor not found",
+		);
+	});
+
+	test("fonto:dita-class has arity 2", () => {
+		const fn = fonto.functions.find((f) => formatQName(f.qname) === "fonto:dita-class");
+		assert.ok(fn, "fonto:dita-class not found");
+		assert.equal(fn.arity, 2);
+	});
+
+	test("functions have @see doc links", () => {
+		const raw = fs.readFileSync(fontoPath, "utf-8");
+		assert.ok(raw.includes("@see https://documentation.fontoxml.com"), "expected @see links");
+	});
+});
+
+describe("runtime defs: completions", () => {
+	function buildImported(libs: string[]) {
+		const byNamespace = new Map(
+			getRuntimeAnalyses(libs)
+				.filter((a) => a.moduleNamespaceUri)
+				.map((a) => [a.moduleNamespaceUri!, a]),
+		);
+		return (analysis: ReturnType<typeof analyze>) => {
+			const imported = new Map<string, ReturnType<typeof analyze>>();
+			for (const imp of analysis.imports) {
+				if (!imp.atPath) {
+					const a = byNamespace.get(imp.namespaceUri);
+					if (a) imported.set(imp.namespaceUri, a);
+				}
+			}
+			return imported;
+		};
+	}
+
+	test("fonto functions appear when namespace is imported", () => {
+		const src = `import module namespace fonto="http://www.fontoxml.com/functions"; fonto:`;
+		const analysis = analyze(src, "file:///main.xq");
+		const imported = buildImported(["fonto"])(analysis);
+		const labels = getCompletions({ textBeforeCursor: "fonto:", cursorOffset: 6 }, analysis, imported).map(
+			(i) => i.label,
+		);
+		assert.ok(labels.includes("selection-common-ancestor"), `expected fonto functions, got ${labels}`);
+	});
+
+	test("fonto functions absent without import", () => {
+		const src = `let $x := 1 return $x`;
+		const analysis = analyze(src, "file:///main.xq");
+		const imported = buildImported(["fonto"])(analysis);
+		const labels = getCompletions({ textBeforeCursor: "fonto:", cursorOffset: 6 }, analysis, imported).map(
+			(i) => i.label,
+		);
+		assert.ok(!labels.includes("selection-common-ancestor"), `fonto functions should not appear without import`);
+	});
+});
+
+describe("runtime defs: existdb smoketest", () => {
+	const existdbDir = path.join(runtimesDir, "existdb");
+	const xqFiles = fs.readdirSync(existdbDir).filter((f) => f.endsWith(".xq"));
+
+	test("all .xq files parse without throwing", () => {
+		const errors: string[] = [];
+		for (const file of xqFiles) {
+			const src = fs.readFileSync(path.join(existdbDir, file), "utf-8");
+			try {
+				analyze(src, `builtin:existdb/${file}`);
+			} catch (e) {
+				errors.push(`${file}: ${e}`);
+			}
+		}
+		assert.deepEqual(errors, [], `parse errors in existdb files`);
+	});
+
+	test("all .xq files export at least one function", () => {
+		const empty: string[] = [];
+		for (const file of xqFiles) {
+			const src = fs.readFileSync(path.join(existdbDir, file), "utf-8");
+			const analysis = analyze(src, `builtin:existdb/${file}`);
+			if (analysis.functions.length === 0) empty.push(file);
+		}
+		assert.deepEqual(empty, [], `existdb files with no functions`);
+	});
+
+	test("request:get-parameter has arity 2 and typed params", () => {
+		const src = fs.readFileSync(path.join(existdbDir, "request.xq"), "utf-8");
+		const analysis = analyze(src, "builtin:existdb/request.xq");
+		const fn = analysis.functions.find(
+			(f) => formatQName(f.qname) === "request:get-parameter" && f.arity === 2,
+		);
+		assert.ok(fn, "request:get-parameter#2 not found");
+		assert.equal(fn.params[0].name, "name");
+		assert.equal(fn.params[0].type, "xs:string");
+	});
+
+	test("sm:create-account has arity 3", () => {
+		const src = fs.readFileSync(path.join(existdbDir, "sm.xq"), "utf-8");
+		const analysis = analyze(src, "builtin:existdb/sm.xq");
+		const fn = analysis.functions.find(
+			(f) => formatQName(f.qname) === "sm:create-account" && f.arity === 3,
+		);
+		assert.ok(fn, "sm:create-account#3 not found");
+	});
+
+	test("cache:put has arity 3 with typed params", () => {
+		const src = fs.readFileSync(path.join(existdbDir, "cache.xq"), "utf-8");
+		const analysis = analyze(src, "builtin:existdb/cache.xq");
+		const fn = analysis.functions.find(
+			(f) => formatQName(f.qname) === "cache:put" && f.arity === 3,
+		);
+		assert.ok(fn, "cache:put#3 not found");
+		assert.equal(fn.params[0].name, "cache-name");
+	});
+
+	test("request functions appear in completions when namespace is imported", () => {
+		const src = `import module namespace request="http://exist-db.org/xquery/request"; request:`;
+		const analysis = analyze(src, "file:///main.xq");
+		const byNamespace = new Map(
+			getRuntimeAnalyses(["existdb"])
+				.filter((a) => a.moduleNamespaceUri)
+				.map((a) => [a.moduleNamespaceUri!, a]),
+		);
+		const imported = new Map<string, ReturnType<typeof analyze>>();
+		for (const imp of analysis.imports) {
+			const a = byNamespace.get(imp.namespaceUri);
+			if (a) imported.set(imp.namespaceUri, a);
+		}
+		const labels = getCompletions({ textBeforeCursor: "request:", cursorOffset: 8 }, analysis, imported).map(
+			(i) => i.label,
+		);
+		assert.ok(labels.includes("get-parameter"), `expected request functions, got ${labels.slice(0, 5)}`);
+		assert.ok(labels.includes("get-header"), `expected get-header in completions`);
+	});
+});

package/src/runtimes.ts

@@ -0,0 +1,70 @@
+import * as path from "path";
+import * as fs from "fs";
+import { fileURLToPath } from "url";
+import { analyze } from "./analyzer.ts";
+import type { FileAnalysis } from "./types.ts";
+
+const runtimesDir = path.join(path.dirname(fileURLToPath(import.meta.url)), "runtimes");
+
+const RUNTIME_FILES: Record<string, string[]> = {
+	fonto: [path.join(runtimesDir, "fonto", "fonto.xq")],
+	existdb: [
+		path.join(runtimesDir, "existdb", "cache.xq"),
+		path.join(runtimesDir, "existdb", "compression.xq"),
+		path.join(runtimesDir, "existdb", "console.xq"),
+		path.join(runtimesDir, "existdb", "contentextraction.xq"),
+		path.join(runtimesDir, "existdb", "counter.xq"),
+		path.join(runtimesDir, "existdb", "crypto.xq"),
+		path.join(runtimesDir, "existdb", "datetime.xq"),
+		path.join(runtimesDir, "existdb", "file.xq"),
+		path.join(runtimesDir, "existdb", "ft.xq"),
+		path.join(runtimesDir, "existdb", "httpclient.xq"),
+		path.join(runtimesDir, "existdb", "image.xq"),
+		path.join(runtimesDir, "existdb", "inspect.xq"),
+		path.join(runtimesDir, "existdb", "kwic.xq"),
+		path.join(runtimesDir, "existdb", "mail.xq"),
+		path.join(runtimesDir, "existdb", "ngram.xq"),
+		path.join(runtimesDir, "existdb", "process.xq"),
+		path.join(runtimesDir, "existdb", "range.xq"),
+		path.join(runtimesDir, "existdb", "repo.xq"),
+		path.join(runtimesDir, "existdb", "request.xq"),
+		path.join(runtimesDir, "existdb", "response.xq"),
+		path.join(runtimesDir, "existdb", "scheduler.xq"),
+		path.join(runtimesDir, "existdb", "session.xq"),
+		path.join(runtimesDir, "existdb", "sm.xq"),
+		path.join(runtimesDir, "existdb", "sort.xq"),
+		path.join(runtimesDir, "existdb", "system.xq"),
+		path.join(runtimesDir, "existdb", "transform.xq"),
+		path.join(runtimesDir, "existdb", "util.xq"),
+		path.join(runtimesDir, "existdb", "validation.xq"),
+		path.join(runtimesDir, "existdb", "xmldb.xq"),
+		path.join(runtimesDir, "existdb", "xmldiff.xq"),
+	],
+};
+
+const runtimeAnalysisCache = new Map<string, FileAnalysis>();
+
+export function getRuntimeAnalyses(runtimes: string[]): FileAnalysis[] {
+	const results: FileAnalysis[] = [];
+	for (const runtime of runtimes) {
+		const filePaths = RUNTIME_FILES[runtime];
+		if (!filePaths) continue;
+		for (const filePath of filePaths) {
+			const cacheKey = filePath;
+			const cached = runtimeAnalysisCache.get(cacheKey);
+			if (cached) {
+				results.push(cached);
+				continue;
+			}
+			try {
+				const text = fs.readFileSync(filePath, "utf-8");
+				const analysis = analyze(text, `builtin:${runtime}`);
+				runtimeAnalysisCache.set(cacheKey, analysis);
+				results.push(analysis);
+			} catch {
+				// ignore missing or unreadable runtime files
+			}
+		}
+	}
+	return results;
+}