@scalar/api-client 2.38.4 → 2.39.1

package/dist/v2/features/editor/helpers/json/get-json-ast-node-from-path.js

@@ -0,0 +1,22 @@
+import { getJsonAstNodeAtPath } from "./json-ast.js";
+import * as monaco from "monaco-editor";
+//#region src/v2/features/editor/helpers/json/get-json-ast-node-from-path.ts
+/**
+* Retrieves a JSON AST node from a Monaco editor model at the specified JSON path.
+*
+* Utilizes Monaco's JSON worker to parse the document and returns the AST node
+* located at the given path, or null if not found.
+*
+* @param model - The Monaco editor text model representing the JSON document.
+* @param path - The JSON path to locate the AST node.
+* @returns A promise resolving to the AST node at the path, or null if not found.
+*/
+var getJsonAstNodeFromPath = async (model, path) => {
+	const jsonDocument = await (await (await monaco.languages.json.getWorker())(model.uri)).parseJSONDocument(model.uri.toString());
+	if (!jsonDocument?.root) return null;
+	return getJsonAstNodeAtPath(jsonDocument.root, path) ?? null;
+};
+//#endregion
+export { getJsonAstNodeFromPath };
+
+//# sourceMappingURL=get-json-ast-node-from-path.js.map

package/dist/v2/features/editor/helpers/json/get-json-ast-node-from-path.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"get-json-ast-node-from-path.js","names":[],"sources":["../../../../../../src/v2/features/editor/helpers/json/get-json-ast-node-from-path.ts"],"sourcesContent":["import * as monaco from 'monaco-editor'\n\nimport type { JsonPath } from './json-ast'\nimport { getJsonAstNodeAtPath } from './json-ast'\n\n/**\n * Retrieves a JSON AST node from a Monaco editor model at the specified JSON path.\n *\n * Utilizes Monaco's JSON worker to parse the document and returns the AST node\n * located at the given path, or null if not found.\n *\n * @param model - The Monaco editor text model representing the JSON document.\n * @param path - The JSON path to locate the AST node.\n * @returns A promise resolving to the AST node at the path, or null if not found.\n */\nexport const getJsonAstNodeFromPath = async (\n  model: monaco.editor.ITextModel,\n  path: JsonPath,\n): Promise<monaco.languages.json.ASTNode | null> => {\n  const worker = await monaco.languages.json.getWorker()\n  const jsonWorker = await worker(model.uri)\n\n  // Monaco's JSON worker keeps an internal (incremental) AST; no JSON.parse needed.\n  const jsonDocument = await jsonWorker.parseJSONDocument(model.uri.toString())\n  if (!jsonDocument?.root) {\n    return null\n  }\n\n  return getJsonAstNodeAtPath(jsonDocument.root, path) ?? null\n}\n"],"mappings":";;;;;;;;;;;;;AAeA,IAAa,yBAAyB,OACpC,OACA,SACkD;CAKlD,MAAM,eAAe,OAHF,OADJ,MAAM,OAAO,UAAU,KAAK,WAAW,EACtB,MAAM,IAAI,EAGJ,kBAAkB,MAAM,IAAI,UAAU,CAAC;AAC7E,KAAI,CAAC,cAAc,KACjB,QAAO;AAGT,QAAO,qBAAqB,aAAa,MAAM,KAAK,IAAI"}

package/dist/v2/features/editor/helpers/json/json-ast.js

@@ -0,0 +1,32 @@
+//#region src/v2/features/editor/helpers/json/json-ast.ts
+/**
+* Traverses the AST of a JSON document to find the node at the provided JsonPath.
+* Returns undefined if the path does not exist in the AST.
+*
+* @param node - The root AST node to begin traversal from.
+* @param path - The path to traverse within the AST, as an array of keys/indices.
+* @returns The AST node at the specified path, or undefined if not found.
+*/
+var getJsonAstNodeAtPath = (node, path) => {
+	let current = node;
+	for (const segment of path) {
+		if (!current) return;
+		if (current.type === "object") {
+			const key = String(segment);
+			current = current.properties.find((p) => p.keyNode.value === key)?.valueNode;
+			continue;
+		}
+		if (current.type === "array") {
+			const index = typeof segment === "number" ? segment : Number.parseInt(String(segment), 10);
+			if (!Number.isFinite(index) || index < 0 || index >= current.items.length) return;
+			current = current.items[index];
+			continue;
+		}
+		return;
+	}
+	return current;
+};
+//#endregion
+export { getJsonAstNodeAtPath };
+
+//# sourceMappingURL=json-ast.js.map

package/dist/v2/features/editor/helpers/json/json-ast.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"json-ast.js","names":[],"sources":["../../../../../../src/v2/features/editor/helpers/json/json-ast.ts"],"sourcesContent":["import type * as monaco from 'monaco-editor'\n\nexport type JsonPath = readonly (string | number)[]\n\n/**\n * Traverses the AST of a JSON document to find the node at the provided JsonPath.\n * Returns undefined if the path does not exist in the AST.\n *\n * @param node - The root AST node to begin traversal from.\n * @param path - The path to traverse within the AST, as an array of keys/indices.\n * @returns The AST node at the specified path, or undefined if not found.\n */\nexport const getJsonAstNodeAtPath = (\n  node: monaco.languages.json.ASTNode | undefined,\n  path: JsonPath,\n): monaco.languages.json.ASTNode | undefined => {\n  let current = node\n\n  for (const segment of path) {\n    if (!current) {\n      // Path does not exist in the AST.\n      return undefined\n    }\n\n    if (current.type === 'object') {\n      // Traverse object properties using the segment as a key.\n      const key = String(segment)\n      const prop = current.properties.find((p) => p.keyNode.value === key)\n      current = prop?.valueNode\n      continue\n    }\n\n    if (current.type === 'array') {\n      // Traverse array items using the segment as an index.\n      const index = typeof segment === 'number' ? segment : Number.parseInt(String(segment), 10)\n      if (!Number.isFinite(index) || index < 0 || index >= current.items.length) {\n        // Invalid index or out-of-bounds.\n        return undefined\n      }\n      current = current.items[index]\n      continue\n    }\n\n    // If current node can't have children referenced by the path, return undefined.\n    return undefined\n  }\n\n  // Return the found node or undefined if not found.\n  return current\n}\n"],"mappings":";;;;;;;;;AAYA,IAAa,wBACX,MACA,SAC8C;CAC9C,IAAI,UAAU;AAEd,MAAK,MAAM,WAAW,MAAM;AAC1B,MAAI,CAAC,QAEH;AAGF,MAAI,QAAQ,SAAS,UAAU;GAE7B,MAAM,MAAM,OAAO,QAAQ;AAE3B,aADa,QAAQ,WAAW,MAAM,MAAM,EAAE,QAAQ,UAAU,IAAI,EACpD;AAChB;;AAGF,MAAI,QAAQ,SAAS,SAAS;GAE5B,MAAM,QAAQ,OAAO,YAAY,WAAW,UAAU,OAAO,SAAS,OAAO,QAAQ,EAAE,GAAG;AAC1F,OAAI,CAAC,OAAO,SAAS,MAAM,IAAI,QAAQ,KAAK,SAAS,QAAQ,MAAM,OAEjE;AAEF,aAAU,QAAQ,MAAM;AACxB;;AAIF;;AAIF,QAAO"}

package/dist/v2/features/editor/helpers/json/json-pointer-links.js

@@ -0,0 +1,104 @@
+import { parseJsonPointerPath } from "./json-pointer-path.js";
+import * as monaco from "monaco-editor";
+//#region src/v2/features/editor/helpers/json/json-pointer-links.ts
+var JSON_POINTER_LINK_SCHEME = "scalar-json-pointer";
+/**
+* Checks if the quote at the given index in the text is an unescaped double quote.
+* An unescaped quote is one not preceded by an odd number of backslashes.
+*
+* @param text - The text string to check within.
+* @param index - The index of the character in text to check.
+* @returns True if the quote is unescaped, false otherwise.
+*/
+var isUnescapedQuote = (text, index) => {
+	if (text[index] !== "\"") return false;
+	let backslashes = 0;
+	for (let i = index - 1; i >= 0 && text[i] === "\\"; i--) backslashes++;
+	return backslashes % 2 === 0;
+};
+/**
+* Finds the bounds (indices) of the nearest quoted string around a given index on the same line.
+* Only considers unescaped double quotes (").
+* Returns the left (opening) and right (closing) quote indices if both are found, or null otherwise.
+*
+* @param line - The string line in which to search.
+* @param index - The index around which to search for the quoted string.
+* @returns An object with `left` and `right` indices, or null if not found.
+*/
+var findQuotedStringBounds = (line, index) => {
+	let left = -1;
+	for (let i = index; i >= 0; i--) if (isUnescapedQuote(line, i)) {
+		left = i;
+		break;
+	}
+	if (left === -1) return null;
+	let right = -1;
+	for (let i = Math.max(left + 1, index); i < line.length; i++) if (isUnescapedQuote(line, i)) {
+		right = i;
+		break;
+	}
+	if (right === -1 || right <= left) return null;
+	return {
+		left,
+		right
+	};
+};
+/**
+* Enables clickable JSON Pointer links in Monaco JSON editor.
+*
+* - Scans for "#/" inside JSON string values, but only within properly quoted, unescaped strings.
+* - When a valid JSON Pointer is found, highlights it (excluding quotes) as a clickable link.
+* - Clicking the link invokes the provided `navigate` function with the decoded pointer.
+*
+* @param navigate Callback to execute on pointer link click.
+*/
+var ensureJsonPointerLinkSupport = (navigate) => {
+	monaco.languages.registerLinkProvider("json", { provideLinks(textModel) {
+		const links = [];
+		const lineCount = textModel.getLineCount();
+		for (let lineNumber = 1; lineNumber <= lineCount; lineNumber++) {
+			const line = textModel.getLineContent(lineNumber);
+			let fromIndex = 0;
+			while (true) {
+				const idx = line.indexOf("#/", fromIndex);
+				if (idx === -1) break;
+				const bounds = findQuotedStringBounds(line, idx);
+				if (!bounds) {
+					fromIndex = idx + 2;
+					continue;
+				}
+				const value = line.slice(bounds.left + 1, bounds.right);
+				if (!parseJsonPointerPath(value)) {
+					fromIndex = bounds.right + 1;
+					continue;
+				}
+				const range = new monaco.Range(lineNumber, bounds.left + 2, lineNumber, bounds.right + 1);
+				links.push({
+					range,
+					url: monaco.Uri.parse(`${JSON_POINTER_LINK_SCHEME}:${encodeURIComponent(value)}`),
+					tooltip: "Follow link"
+				});
+				fromIndex = bounds.right + 1;
+			}
+		}
+		return { links };
+	} });
+	const linkOpener = monaco.editor.registerLinkOpener({ open(resource) {
+		if (resource.scheme !== JSON_POINTER_LINK_SCHEME) return false;
+		const encoded = (resource.path || "").replace(/^\//, "");
+		const pointer = decodeURIComponent(encoded);
+		if (!pointer) return false;
+		return Promise.resolve(navigate(pointer)).then(() => true);
+	} });
+	const dispose = () => {
+		linkOpener.dispose();
+	};
+	return {
+		linkOpener,
+		dispose
+	};
+};
+//#endregion
+export { ensureJsonPointerLinkSupport };
+
+//# sourceMappingURL=json-pointer-links.js.map

package/dist/v2/features/editor/helpers/json/json-pointer-links.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"json-pointer-links.js","names":[],"sources":["../../../../../../src/v2/features/editor/helpers/json/json-pointer-links.ts"],"sourcesContent":["import * as monaco from 'monaco-editor'\n\nimport { parseJsonPointerPath } from './json-pointer-path'\n\nconst JSON_POINTER_LINK_SCHEME = 'scalar-json-pointer'\n\n/**\n * Checks if the quote at the given index in the text is an unescaped double quote.\n * An unescaped quote is one not preceded by an odd number of backslashes.\n *\n * @param text - The text string to check within.\n * @param index - The index of the character in text to check.\n * @returns True if the quote is unescaped, false otherwise.\n */\nconst isUnescapedQuote = (text: string, index: number): boolean => {\n  if (text[index] !== '\"') {\n    return false\n  }\n\n  let backslashes = 0\n  // Count consecutive backslashes immediately before the quote\n  for (let i = index - 1; i >= 0 && text[i] === '\\\\'; i--) {\n    backslashes++\n  }\n  // If even number of backslashes, quote is unescaped\n  return backslashes % 2 === 0\n}\n\n/**\n * Finds the bounds (indices) of the nearest quoted string around a given index on the same line.\n * Only considers unescaped double quotes (\").\n * Returns the left (opening) and right (closing) quote indices if both are found, or null otherwise.\n *\n * @param line - The string line in which to search.\n * @param index - The index around which to search for the quoted string.\n * @returns An object with `left` and `right` indices, or null if not found.\n */\nconst findQuotedStringBounds = (line: string, index: number): { left: number; right: number } | null => {\n  // Find the nearest unescaped quote to the left (including the current index)\n  let left = -1\n  for (let i = index; i >= 0; i--) {\n    if (isUnescapedQuote(line, i)) {\n      left = i\n      break\n    }\n  }\n  if (left === -1) {\n    // No opening quote found\n    return null\n  }\n\n  // Find the nearest unescaped quote to the right after the opening quote\n  let right = -1\n  for (let i = Math.max(left + 1, index); i < line.length; i++) {\n    if (isUnescapedQuote(line, i)) {\n      right = i\n      break\n    }\n  }\n  // If there is no closing quote or it appears before the opening, return null\n  if (right === -1 || right <= left) {\n    return null\n  }\n\n  return { left, right }\n}\n\n/**\n * Enables clickable JSON Pointer links in Monaco JSON editor.\n *\n * - Scans for \"#/\" inside JSON string values, but only within properly quoted, unescaped strings.\n * - When a valid JSON Pointer is found, highlights it (excluding quotes) as a clickable link.\n * - Clicking the link invokes the provided `navigate` function with the decoded pointer.\n *\n * @param navigate Callback to execute on pointer link click.\n */\nexport const ensureJsonPointerLinkSupport = (navigate: (pointer: string) => Promise<void> | void) => {\n  monaco.languages.registerLinkProvider('json', {\n    provideLinks(textModel) {\n      const links: monaco.languages.ILink[] = []\n\n      const lineCount = textModel.getLineCount()\n      for (let lineNumber = 1; lineNumber <= lineCount; lineNumber++) {\n        const line = textModel.getLineContent(lineNumber)\n        let fromIndex = 0\n\n        while (true) {\n          // Look for JSON Pointer prefix in the line starting from fromIndex\n          const idx = line.indexOf('#/', fromIndex)\n          if (idx === -1) {\n            break\n          }\n\n          // Try to find quoted string bounds around found #/\n          const bounds = findQuotedStringBounds(line, idx)\n          if (!bounds) {\n            fromIndex = idx + 2\n            continue\n          }\n\n          // Extract the value inside quotes\n          const value = line.slice(bounds.left + 1, bounds.right)\n          // Only create a link if this is a valid JSON Pointer\n          if (!parseJsonPointerPath(value)) {\n            fromIndex = bounds.right + 1\n            continue\n          }\n\n          // Exclude string quotes when creating the link's range\n          const range = new monaco.Range(lineNumber, bounds.left + 2, lineNumber, bounds.right + 1)\n\n          // Add the link to the collection\n          links.push({\n            range,\n            url: monaco.Uri.parse(`${JSON_POINTER_LINK_SCHEME}:${encodeURIComponent(value)}`),\n            tooltip: 'Follow link',\n          })\n\n          // Advance search past the string we just handled\n          fromIndex = bounds.right + 1\n        }\n      }\n\n      return { links }\n    },\n  })\n\n  const linkOpener = monaco.editor.registerLinkOpener({\n    open(resource) {\n      // Only handle our special JSON pointer link scheme\n      if (resource.scheme !== JSON_POINTER_LINK_SCHEME) {\n        return false\n      }\n\n      // Remove leading slash from resource path, if any\n      const encoded = (resource.path || '').replace(/^\\//, '')\n      const pointer = decodeURIComponent(encoded)\n      if (!pointer) {\n        return false\n      }\n\n      // Invoke the navigate callback, resolve to true on successful navigation\n      return Promise.resolve(navigate(pointer)).then(() => true)\n    },\n  })\n\n  const dispose = () => {\n    linkOpener.dispose()\n  }\n\n  return { linkOpener, dispose }\n}\n"],"mappings":";;;AAIA,IAAM,2BAA2B;;;;;;;;;AAUjC,IAAM,oBAAoB,MAAc,UAA2B;AACjE,KAAI,KAAK,WAAW,KAClB,QAAO;CAGT,IAAI,cAAc;AAElB,MAAK,IAAI,IAAI,QAAQ,GAAG,KAAK,KAAK,KAAK,OAAO,MAAM,IAClD;AAGF,QAAO,cAAc,MAAM;;;;;;;;;;;AAY7B,IAAM,0BAA0B,MAAc,UAA0D;CAEtG,IAAI,OAAO;AACX,MAAK,IAAI,IAAI,OAAO,KAAK,GAAG,IAC1B,KAAI,iBAAiB,MAAM,EAAE,EAAE;AAC7B,SAAO;AACP;;AAGJ,KAAI,SAAS,GAEX,QAAO;CAIT,IAAI,QAAQ;AACZ,MAAK,IAAI,IAAI,KAAK,IAAI,OAAO,GAAG,MAAM,EAAE,IAAI,KAAK,QAAQ,IACvD,KAAI,iBAAiB,MAAM,EAAE,EAAE;AAC7B,UAAQ;AACR;;AAIJ,KAAI,UAAU,MAAM,SAAS,KAC3B,QAAO;AAGT,QAAO;EAAE;EAAM;EAAO;;;;;;;;;;;AAYxB,IAAa,gCAAgC,aAAwD;AACnG,QAAO,UAAU,qBAAqB,QAAQ,EAC5C,aAAa,WAAW;EACtB,MAAM,QAAkC,EAAE;EAE1C,MAAM,YAAY,UAAU,cAAc;AAC1C,OAAK,IAAI,aAAa,GAAG,cAAc,WAAW,cAAc;GAC9D,MAAM,OAAO,UAAU,eAAe,WAAW;GACjD,IAAI,YAAY;AAEhB,UAAO,MAAM;IAEX,MAAM,MAAM,KAAK,QAAQ,MAAM,UAAU;AACzC,QAAI,QAAQ,GACV;IAIF,MAAM,SAAS,uBAAuB,MAAM,IAAI;AAChD,QAAI,CAAC,QAAQ;AACX,iBAAY,MAAM;AAClB;;IAIF,MAAM,QAAQ,KAAK,MAAM,OAAO,OAAO,GAAG,OAAO,MAAM;AAEvD,QAAI,CAAC,qBAAqB,MAAM,EAAE;AAChC,iBAAY,OAAO,QAAQ;AAC3B;;IAIF,MAAM,QAAQ,IAAI,OAAO,MAAM,YAAY,OAAO,OAAO,GAAG,YAAY,OAAO,QAAQ,EAAE;AAGzF,UAAM,KAAK;KACT;KACA,KAAK,OAAO,IAAI,MAAM,GAAG,yBAAyB,GAAG,mBAAmB,MAAM,GAAG;KACjF,SAAS;KACV,CAAC;AAGF,gBAAY,OAAO,QAAQ;;;AAI/B,SAAO,EAAE,OAAO;IAEnB,CAAC;CAEF,MAAM,aAAa,OAAO,OAAO,mBAAmB,EAClD,KAAK,UAAU;AAEb,MAAI,SAAS,WAAW,yBACtB,QAAO;EAIT,MAAM,WAAW,SAAS,QAAQ,IAAI,QAAQ,OAAO,GAAG;EACxD,MAAM,UAAU,mBAAmB,QAAQ;AAC3C,MAAI,CAAC,QACH,QAAO;AAIT,SAAO,QAAQ,QAAQ,SAAS,QAAQ,CAAC,CAAC,WAAW,KAAK;IAE7D,CAAC;CAEF,MAAM,gBAAgB;AACpB,aAAW,SAAS;;AAGtB,QAAO;EAAE;EAAY;EAAS"}

package/dist/v2/features/editor/helpers/json/json-pointer-path.d.ts

@@ -1,4 +1,4 @@
-import type { JsonPath } from './json-ast';
+import type { JsonPath } from './json-ast.js';
 /**
  * Parses a JSON Pointer (RFC 6901) and returns a "JSON path" compatible with this editor.
  * Supports raw pointers ("/paths/...") and URI fragments ("#/paths/...").

package/dist/v2/features/editor/helpers/json/json-pointer-path.js

@@ -0,0 +1,27 @@
+import { parseJsonPointerSegments } from "@scalar/helpers/json/parse-json-pointer-segments";
+//#region src/v2/features/editor/helpers/json/json-pointer-path.ts
+var extractPointer = (input) => {
+	const trimmed = input.trim();
+	if (trimmed.startsWith("/")) return trimmed;
+	if (trimmed.startsWith("#")) {
+		const fragment = trimmed.slice(1);
+		return fragment.startsWith("/") ? fragment : null;
+	}
+	const hashIndex = trimmed.indexOf("#");
+	if (hashIndex === -1) return null;
+	const fragment = trimmed.slice(hashIndex + 1);
+	return fragment.startsWith("/") ? fragment : null;
+};
+/**
+* Parses a JSON Pointer (RFC 6901) and returns a "JSON path" compatible with this editor.
+* Supports raw pointers ("/paths/...") and URI fragments ("#/paths/...").
+*/
+var parseJsonPointerPath = (pointer) => {
+	const extracted = extractPointer(pointer);
+	if (!extracted) return null;
+	return parseJsonPointerSegments(extracted);
+};
+//#endregion
+export { parseJsonPointerPath };
+
+//# sourceMappingURL=json-pointer-path.js.map

package/dist/v2/features/editor/helpers/json/json-pointer-path.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"json-pointer-path.js","names":[],"sources":["../../../../../../src/v2/features/editor/helpers/json/json-pointer-path.ts"],"sourcesContent":["import { parseJsonPointerSegments } from '@scalar/helpers/json/parse-json-pointer-segments'\n\nimport type { JsonPath } from './json-ast'\n\nconst extractPointer = (input: string): string | null => {\n  const trimmed = input.trim()\n\n  // Pure RFC6901 pointers\n  if (trimmed.startsWith('/')) {\n    return trimmed\n  }\n\n  // URI fragments like \"#/paths/...\"\n  if (trimmed.startsWith('#')) {\n    const fragment = trimmed.slice(1)\n    return fragment.startsWith('/') ? fragment : null\n  }\n\n  // URIs with fragments like \"file.json#/paths/...\"\n  const hashIndex = trimmed.indexOf('#')\n  if (hashIndex === -1) {\n    return null\n  }\n\n  const fragment = trimmed.slice(hashIndex + 1)\n  return fragment.startsWith('/') ? fragment : null\n}\n\n/**\n * Parses a JSON Pointer (RFC 6901) and returns a \"JSON path\" compatible with this editor.\n * Supports raw pointers (\"/paths/...\") and URI fragments (\"#/paths/...\").\n */\nexport const parseJsonPointerPath = (pointer: string): JsonPath | null => {\n  const extracted = extractPointer(pointer)\n  if (!extracted) {\n    return null\n  }\n\n  return parseJsonPointerSegments(extracted)\n}\n"],"mappings":";;AAIA,IAAM,kBAAkB,UAAiC;CACvD,MAAM,UAAU,MAAM,MAAM;AAG5B,KAAI,QAAQ,WAAW,IAAI,CACzB,QAAO;AAIT,KAAI,QAAQ,WAAW,IAAI,EAAE;EAC3B,MAAM,WAAW,QAAQ,MAAM,EAAE;AACjC,SAAO,SAAS,WAAW,IAAI,GAAG,WAAW;;CAI/C,MAAM,YAAY,QAAQ,QAAQ,IAAI;AACtC,KAAI,cAAc,GAChB,QAAO;CAGT,MAAM,WAAW,QAAQ,MAAM,YAAY,EAAE;AAC7C,QAAO,SAAS,WAAW,IAAI,GAAG,WAAW;;;;;;AAO/C,IAAa,wBAAwB,YAAqC;CACxE,MAAM,YAAY,eAAe,QAAQ;AACzC,KAAI,CAAC,UACH,QAAO;AAGT,QAAO,yBAAyB,UAAU"}

package/dist/v2/features/editor/helpers/range-to-whole-line.js

@@ -0,0 +1,27 @@
+import * as monaco from "monaco-editor";
+//#region src/v2/features/editor/helpers/range-to-whole-line.ts
+/**
+* Expands a given range to cover whole lines within a Monaco editor model.
+*
+* Given a text model and an input range, this function calculates the smallest
+* and largest lines touched by the range and returns a new range that starts at
+* the beginning of the first touched line and ends at the end of the last touched line.
+*
+* @param model The Monaco editor text model.
+* @param range The Monaco Range to expand.
+* @returns A new Monaco Range covering the whole lines spanned by the given range.
+*/
+var rangeToWholeLine = (model, range) => {
+	const startOffset = model.getOffsetAt(range.getStartPosition());
+	const endOffset = model.getOffsetAt(range.getEndPosition());
+	const start = model.getPositionAt(startOffset);
+	const inclusiveEndOffset = Math.max(startOffset, endOffset - 1);
+	const end = model.getPositionAt(inclusiveEndOffset);
+	const startLine = Math.max(1, start.lineNumber);
+	const endLine = Math.max(startLine, end.lineNumber);
+	return new monaco.Range(startLine, 1, endLine, model.getLineMaxColumn(endLine));
+};
+//#endregion
+export { rangeToWholeLine };
+
+//# sourceMappingURL=range-to-whole-line.js.map

package/dist/v2/features/editor/helpers/range-to-whole-line.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"range-to-whole-line.js","names":[],"sources":["../../../../../src/v2/features/editor/helpers/range-to-whole-line.ts"],"sourcesContent":["import * as monaco from 'monaco-editor'\n\n/**\n * Expands a given range to cover whole lines within a Monaco editor model.\n *\n * Given a text model and an input range, this function calculates the smallest\n * and largest lines touched by the range and returns a new range that starts at\n * the beginning of the first touched line and ends at the end of the last touched line.\n *\n * @param model The Monaco editor text model.\n * @param range The Monaco Range to expand.\n * @returns A new Monaco Range covering the whole lines spanned by the given range.\n */\nexport const rangeToWholeLine = (model: monaco.editor.ITextModel, range: monaco.Range): monaco.Range => {\n  const startOffset = model.getOffsetAt(range.getStartPosition())\n  const endOffset = model.getOffsetAt(range.getEndPosition())\n  const start = model.getPositionAt(startOffset)\n  const inclusiveEndOffset = Math.max(startOffset, endOffset - 1)\n  const end = model.getPositionAt(inclusiveEndOffset)\n  const startLine = Math.max(1, start.lineNumber)\n  const endLine = Math.max(startLine, end.lineNumber)\n  return new monaco.Range(startLine, 1, endLine, model.getLineMaxColumn(endLine))\n}\n"],"mappings":";;;;;;;;;;;;;AAaA,IAAa,oBAAoB,OAAiC,UAAsC;CACtG,MAAM,cAAc,MAAM,YAAY,MAAM,kBAAkB,CAAC;CAC/D,MAAM,YAAY,MAAM,YAAY,MAAM,gBAAgB,CAAC;CAC3D,MAAM,QAAQ,MAAM,cAAc,YAAY;CAC9C,MAAM,qBAAqB,KAAK,IAAI,aAAa,YAAY,EAAE;CAC/D,MAAM,MAAM,MAAM,cAAc,mBAAmB;CACnD,MAAM,YAAY,KAAK,IAAI,GAAG,MAAM,WAAW;CAC/C,MAAM,UAAU,KAAK,IAAI,WAAW,IAAI,WAAW;AACnD,QAAO,IAAI,OAAO,MAAM,WAAW,GAAG,SAAS,MAAM,iBAAiB,QAAQ,CAAC"}

package/dist/v2/features/editor/helpers/theme/apply-scalar-theme.js

@@ -0,0 +1,84 @@
+import { loadCssVariables } from "./load-css-variables.js";
+import * as monaco from "monaco-editor";
+//#region src/v2/features/editor/helpers/theme/apply-scalar-theme.ts
+var THEME_NAME = "scalar-theme";
+/**
+* Applies a custom Scalar theme to the Monaco editor.
+*
+* This function loads CSS variables for either dark or light mode, maps the colors to Monaco's editor theme keys,
+* and then applies the new theme. Theme color tokens are resolved from CSS custom properties.
+*
+* Example usage:
+*
+*   await applyScalarTheme('scalar', true);  // Apply dark mode
+*   await applyScalarTheme('scalar', false); // Apply light mode
+*
+* @param theme - The theme string key to load variables for (e.g. 'scalar').
+* @param isDarkMode - Whether to use dark or light variables.
+*/
+var applyScalarTheme = async (theme, isDarkMode) => {
+	const allVars = await loadCssVariables(theme);
+	const vars = isDarkMode ? allVars.dark : allVars.light;
+	/**
+	* Build a colors object for Monaco from the variable map.
+	* Only assign if the variable exists in the loaded vars.
+	*/
+	const colors = Object.fromEntries(Object.entries({
+		"editor.background": "--scalar-background-1",
+		"editor.foreground": "--scalar-color-1",
+		"editorLineNumber.foreground": "--scalar-color-3",
+		"editorLineNumber.activeForeground": "--scalar-color-1",
+		"editorLineHighlight.background": "--scalar-background-2",
+		"editorCursor.foreground": "--scalar-color-1",
+		"editorCursor.background": "--scalar-background-1",
+		"editor.selectionBackground": "--scalar-background-3",
+		"editor.inactiveSelectionBackground": "--scalar-background-3",
+		"editorIndentGuide.background": "--scalar-background-3",
+		"editorIndentGuide.activeBackground": "--scalar-background-2",
+		"editorWhitespace.foreground": "--scalar-border-color",
+		"editorBracketMatch.background": "--scalar-background-3",
+		"editorBracketMatch.border": "--scalar-color-accent",
+		"editor.selectionHighlightBackground": "--scalar-background-3",
+		"editor.hoverHighlightBackground": "--scalar-background-3",
+		"editorLink.activeForeground": "--scalar-color-3",
+		"editorOverviewRuler.border": "--scalar-border-color"
+	}).filter(([_, cssVar]) => !!vars[cssVar]).map(([prop, cssVar]) => [prop, vars[cssVar]]));
+	monaco.editor.defineTheme(THEME_NAME, {
+		base: isDarkMode ? "vs-dark" : "vs",
+		inherit: true,
+		rules: [
+			{
+				token: "",
+				foreground: vars["--scalar-color-3"]
+			},
+			{
+				token: "comment",
+				foreground: vars["--scalar-color-2"],
+				fontStyle: "italic"
+			},
+			{
+				token: "keyword",
+				foreground: vars["--scalar-color-accent"],
+				fontStyle: "bold"
+			},
+			{
+				token: "number",
+				foreground: vars["--scalar-color-purple"]
+			},
+			{
+				token: "string",
+				foreground: vars["--scalar-color-2"]
+			},
+			{
+				token: "delimiter",
+				foreground: vars["--scalar-color-3"]
+			}
+		],
+		colors
+	});
+	monaco.editor.setTheme(THEME_NAME);
+};
+//#endregion
+export { applyScalarTheme };
+
+//# sourceMappingURL=apply-scalar-theme.js.map

package/dist/v2/features/editor/helpers/theme/apply-scalar-theme.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"apply-scalar-theme.js","names":[],"sources":["../../../../../../src/v2/features/editor/helpers/theme/apply-scalar-theme.ts"],"sourcesContent":["import * as monaco from 'monaco-editor'\n\nimport { loadCssVariables } from './load-css-variables'\n\nconst THEME_NAME = 'scalar-theme'\n\n/**\n * Applies a custom Scalar theme to the Monaco editor.\n *\n * This function loads CSS variables for either dark or light mode, maps the colors to Monaco's editor theme keys,\n * and then applies the new theme. Theme color tokens are resolved from CSS custom properties.\n *\n * Example usage:\n *\n *   await applyScalarTheme('scalar', true);  // Apply dark mode\n *   await applyScalarTheme('scalar', false); // Apply light mode\n *\n * @param theme - The theme string key to load variables for (e.g. 'scalar').\n * @param isDarkMode - Whether to use dark or light variables.\n */\nexport const applyScalarTheme = async (theme: string, isDarkMode: boolean) => {\n  // Load all CSS variables for the given theme\n  const allVars = await loadCssVariables(theme)\n\n  // Pick variables for dark or light mode\n  const vars = isDarkMode ? allVars.dark : allVars.light\n\n  /**\n   * Map Monaco editor theme keys to CSS variable names.\n   */\n  const varsMap = {\n    'editor.background': '--scalar-background-1',\n    'editor.foreground': '--scalar-color-1',\n    'editorLineNumber.foreground': '--scalar-color-3',\n    'editorLineNumber.activeForeground': '--scalar-color-1',\n    'editorLineHighlight.background': '--scalar-background-2',\n    'editorCursor.foreground': '--scalar-color-1',\n    'editorCursor.background': '--scalar-background-1',\n    'editor.selectionBackground': '--scalar-background-3',\n    'editor.inactiveSelectionBackground': '--scalar-background-3',\n    'editorIndentGuide.background': '--scalar-background-3',\n    'editorIndentGuide.activeBackground': '--scalar-background-2',\n    'editorWhitespace.foreground': '--scalar-border-color',\n    'editorBracketMatch.background': '--scalar-background-3',\n    'editorBracketMatch.border': '--scalar-color-accent',\n    'editor.selectionHighlightBackground': '--scalar-background-3',\n    'editor.hoverHighlightBackground': '--scalar-background-3',\n    'editorLink.activeForeground': '--scalar-color-3',\n    'editorOverviewRuler.border': '--scalar-border-color',\n  }\n\n  /**\n   * Build a colors object for Monaco from the variable map.\n   * Only assign if the variable exists in the loaded vars.\n   */\n  const colors = Object.fromEntries(\n    Object.entries(varsMap)\n      .filter(([_, cssVar]) => !!vars[cssVar])\n      .map(([prop, cssVar]) => [prop, vars[cssVar]]),\n  )\n\n  // Define the theme in Monaco using the chosen variables.\n  monaco.editor.defineTheme(THEME_NAME, {\n    base: isDarkMode ? 'vs-dark' : 'vs',\n    inherit: true,\n    rules: [\n      // Default text\n      { token: '', foreground: vars['--scalar-color-3'] },\n      // Comments\n      {\n        token: 'comment',\n        foreground: vars['--scalar-color-2'],\n        fontStyle: 'italic',\n      },\n      // Keywords\n      {\n        token: 'keyword',\n        foreground: vars['--scalar-color-accent'],\n        fontStyle: 'bold',\n      },\n      // Numbers\n      { token: 'number', foreground: vars['--scalar-color-purple'] },\n      // Strings\n      { token: 'string', foreground: vars['--scalar-color-2'] },\n      // Delimiters (punctuation)\n      { token: 'delimiter', foreground: vars['--scalar-color-3'] },\n    ],\n    colors,\n  })\n\n  // Finally, set the theme\n  monaco.editor.setTheme(THEME_NAME)\n}\n"],"mappings":";;;AAIA,IAAM,aAAa;;;;;;;;;;;;;;;AAgBnB,IAAa,mBAAmB,OAAO,OAAe,eAAwB;CAE5E,MAAM,UAAU,MAAM,iBAAiB,MAAM;CAG7C,MAAM,OAAO,aAAa,QAAQ,OAAO,QAAQ;;;;;CA8BjD,MAAM,SAAS,OAAO,YACpB,OAAO,QA1BO;EACd,qBAAqB;EACrB,qBAAqB;EACrB,+BAA+B;EAC/B,qCAAqC;EACrC,kCAAkC;EAClC,2BAA2B;EAC3B,2BAA2B;EAC3B,8BAA8B;EAC9B,sCAAsC;EACtC,gCAAgC;EAChC,sCAAsC;EACtC,+BAA+B;EAC/B,iCAAiC;EACjC,6BAA6B;EAC7B,uCAAuC;EACvC,mCAAmC;EACnC,+BAA+B;EAC/B,8BAA8B;EAC/B,CAOwB,CACpB,QAAQ,CAAC,GAAG,YAAY,CAAC,CAAC,KAAK,QAAQ,CACvC,KAAK,CAAC,MAAM,YAAY,CAAC,MAAM,KAAK,QAAQ,CAAC,CACjD;AAGD,QAAO,OAAO,YAAY,YAAY;EACpC,MAAM,aAAa,YAAY;EAC/B,SAAS;EACT,OAAO;GAEL;IAAE,OAAO;IAAI,YAAY,KAAK;IAAqB;GAEnD;IACE,OAAO;IACP,YAAY,KAAK;IACjB,WAAW;IACZ;GAED;IACE,OAAO;IACP,YAAY,KAAK;IACjB,WAAW;IACZ;GAED;IAAE,OAAO;IAAU,YAAY,KAAK;IAA0B;GAE9D;IAAE,OAAO;IAAU,YAAY,KAAK;IAAqB;GAEzD;IAAE,OAAO;IAAa,YAAY,KAAK;IAAqB;GAC7D;EACD;EACD,CAAC;AAGF,QAAO,OAAO,SAAS,WAAW"}

package/dist/v2/features/editor/helpers/theme/load-css-variables.js

@@ -0,0 +1,41 @@
+import { z } from "zod";
+//#region src/v2/features/editor/helpers/theme/load-css-variables.ts
+/**
+* Extracts CSS custom properties (variables) from a given CSS string
+* for .light-mode and .dark-mode selectors and returns an object
+* with 'light' and 'dark' keys containing the filtered variables.
+* Only variables matching hex color values (#RRGGBB or #RRGGBBAA) are accepted.
+*
+* @param css - The CSS string to parse.
+* @returns An object with `light` and `dark` properties containing the extracted CSS variables.
+*/
+var loadCssVariables = async (css) => {
+	const sheet = new CSSStyleSheet();
+	await sheet.replace(css);
+	return Array.from(sheet.cssRules).reduce((acc, cur) => {
+		if (!(cur instanceof CSSStyleRule)) return acc;
+		const styles = Object.values(cur.style).reduce((style, name) => {
+			if (!name.startsWith("--")) return style;
+			const value = z.string().regex(/^(?:#(?:[0-9A-F]{6}|[0-9A-F]{8}))$/i).safeParse(cur.style.getPropertyValue(name).toUpperCase().trim());
+			if (value.error) return style;
+			style[name] = value.data;
+			return style;
+		}, {});
+		if (cur.selectorText.includes(".light-mode")) acc.light = {
+			...acc.light,
+			...styles
+		};
+		if (cur.selectorText.includes(".dark-mode")) acc.dark = {
+			...acc.dark,
+			...styles
+		};
+		return acc;
+	}, {
+		light: {},
+		dark: {}
+	});
+};
+//#endregion
+export { loadCssVariables };
+
+//# sourceMappingURL=load-css-variables.js.map

package/dist/v2/features/editor/helpers/theme/load-css-variables.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"load-css-variables.js","names":[],"sources":["../../../../../../src/v2/features/editor/helpers/theme/load-css-variables.ts"],"sourcesContent":["import { z } from 'zod'\n\n/**\n * Extracts CSS custom properties (variables) from a given CSS string\n * for .light-mode and .dark-mode selectors and returns an object\n * with 'light' and 'dark' keys containing the filtered variables.\n * Only variables matching hex color values (#RRGGBB or #RRGGBBAA) are accepted.\n *\n * @param css - The CSS string to parse.\n * @returns An object with `light` and `dark` properties containing the extracted CSS variables.\n */\nexport const loadCssVariables = async (css: string) => {\n  const sheet = new CSSStyleSheet()\n  await sheet.replace(css)\n\n  const parsed = Array.from(sheet.cssRules).reduce<{ light: any; dark: any }>(\n    (acc, cur) => {\n      // Process only style rules (skip e.g. media, font-face, etc.)\n      if (!(cur instanceof CSSStyleRule)) {\n        return acc\n      }\n\n      // Collect valid CSS variable declarations from the rule's style\n      const styles = Object.values(cur.style).reduce<Record<string, string>>((style, name) => {\n        if (!name.startsWith('--')) {\n          return style\n        }\n\n        // Only accept variables that match hex color format\n        const value = z\n          .string()\n          .regex(/^(?:#(?:[0-9A-F]{6}|[0-9A-F]{8}))$/i)\n          .safeParse(cur.style.getPropertyValue(name).toUpperCase().trim())\n\n        if (value.error) {\n          return style\n        }\n\n        style[name] = value.data\n\n        return style\n      }, {})\n\n      // Merge variables into the correct theme object based on selector\n      if (cur.selectorText.includes('.light-mode')) {\n        acc.light = { ...acc.light, ...styles }\n      }\n\n      if (cur.selectorText.includes('.dark-mode')) {\n        acc.dark = { ...acc.dark, ...styles }\n      }\n\n      return acc\n    },\n    { light: {}, dark: {} },\n  )\n\n  return parsed\n}\n"],"mappings":";;;;;;;;;;;AAWA,IAAa,mBAAmB,OAAO,QAAgB;CACrD,MAAM,QAAQ,IAAI,eAAe;AACjC,OAAM,MAAM,QAAQ,IAAI;AA4CxB,QA1Ce,MAAM,KAAK,MAAM,SAAS,CAAC,QACvC,KAAK,QAAQ;AAEZ,MAAI,EAAE,eAAe,cACnB,QAAO;EAIT,MAAM,SAAS,OAAO,OAAO,IAAI,MAAM,CAAC,QAAgC,OAAO,SAAS;AACtF,OAAI,CAAC,KAAK,WAAW,KAAK,CACxB,QAAO;GAIT,MAAM,QAAQ,EACX,QAAQ,CACR,MAAM,sCAAsC,CAC5C,UAAU,IAAI,MAAM,iBAAiB,KAAK,CAAC,aAAa,CAAC,MAAM,CAAC;AAEnE,OAAI,MAAM,MACR,QAAO;AAGT,SAAM,QAAQ,MAAM;AAEpB,UAAO;KACN,EAAE,CAAC;AAGN,MAAI,IAAI,aAAa,SAAS,cAAc,CAC1C,KAAI,QAAQ;GAAE,GAAG,IAAI;GAAO,GAAG;GAAQ;AAGzC,MAAI,IAAI,aAAa,SAAS,aAAa,CACzC,KAAI,OAAO;GAAE,GAAG,IAAI;GAAM,GAAG;GAAQ;AAGvC,SAAO;IAET;EAAE,OAAO,EAAE;EAAE,MAAM,EAAE;EAAE,CACxB"}

package/dist/v2/features/editor/helpers/yaml/create-yaml-model.js

@@ -0,0 +1,32 @@
+import { configureYaml } from "../configure-language-support.js";
+import { getYamlNodeRangeFromPath } from "./get-yaml-node-range-from-path.js";
+import * as monaco from "monaco-editor";
+//#region src/v2/features/editor/helpers/yaml/create-yaml-model.ts
+/**
+* Creates a YAML model for use in the Monaco editor.
+*
+* @param value - The initial YAML string value for the model.
+* @returns An object containing the Monaco model and a method to get a range from a YAML path.
+*
+* The created model is configured for YAML language support.
+* The `getRangeFromPath` method returns a Monaco Range object indicating the text range
+* that corresponds to a given path in the YAML document, or null if the path is not found.
+*/
+var createYamlModel = (value) => {
+	const model = monaco.editor.createModel(value ?? "", "yaml");
+	configureYaml(model.uri.toString());
+	return {
+		model,
+		getRangeFromPath: (path) => {
+			const range = getYamlNodeRangeFromPath(model.getValue(), path);
+			if (!range) return null;
+			const start = model.getPositionAt(range.startOffset);
+			const end = model.getPositionAt(range.endOffset);
+			return new monaco.Range(start.lineNumber, start.column, end.lineNumber, end.column);
+		}
+	};
+};
+//#endregion
+export { createYamlModel };
+
+//# sourceMappingURL=create-yaml-model.js.map

package/dist/v2/features/editor/helpers/yaml/create-yaml-model.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"create-yaml-model.js","names":[],"sources":["../../../../../../src/v2/features/editor/helpers/yaml/create-yaml-model.ts"],"sourcesContent":["import * as monaco from 'monaco-editor'\n\nimport { configureYaml } from '@/v2/features/editor/helpers/configure-language-support'\nimport type { EditorModel, Path } from '@/v2/features/editor/helpers/model'\nimport { getYamlNodeRangeFromPath } from '@/v2/features/editor/helpers/yaml/get-yaml-node-range-from-path'\n\n/**\n * Creates a YAML model for use in the Monaco editor.\n *\n * @param value - The initial YAML string value for the model.\n * @returns An object containing the Monaco model and a method to get a range from a YAML path.\n *\n * The created model is configured for YAML language support.\n * The `getRangeFromPath` method returns a Monaco Range object indicating the text range\n * that corresponds to a given path in the YAML document, or null if the path is not found.\n */\nexport const createYamlModel = (value?: string): EditorModel => {\n  const model = monaco.editor.createModel(value ?? '', 'yaml')\n\n  // Configure language support\n  configureYaml(model.uri.toString())\n\n  return {\n    model,\n    getRangeFromPath: (path: Path) => {\n      const range = getYamlNodeRangeFromPath(model.getValue(), path)\n      if (!range) {\n        return null\n      }\n\n      const start = model.getPositionAt(range.startOffset)\n      const end = model.getPositionAt(range.endOffset)\n\n      return new monaco.Range(start.lineNumber, start.column, end.lineNumber, end.column)\n    },\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;AAgBA,IAAa,mBAAmB,UAAgC;CAC9D,MAAM,QAAQ,OAAO,OAAO,YAAY,SAAS,IAAI,OAAO;AAG5D,eAAc,MAAM,IAAI,UAAU,CAAC;AAEnC,QAAO;EACL;EACA,mBAAmB,SAAe;GAChC,MAAM,QAAQ,yBAAyB,MAAM,UAAU,EAAE,KAAK;AAC9D,OAAI,CAAC,MACH,QAAO;GAGT,MAAM,QAAQ,MAAM,cAAc,MAAM,YAAY;GACpD,MAAM,MAAM,MAAM,cAAc,MAAM,UAAU;AAEhD,UAAO,IAAI,OAAO,MAAM,MAAM,YAAY,MAAM,QAAQ,IAAI,YAAY,IAAI,OAAO;;EAEtF"}

package/dist/v2/features/editor/helpers/yaml/get-yaml-node-range-from-path.js

@@ -0,0 +1,70 @@
+import { isMap, isPair, isScalar, isSeq, parseDocument } from "yaml";
+//#region src/v2/features/editor/helpers/yaml/get-yaml-node-range-from-path.ts
+var isValidYamlRange = (range) => Array.isArray(range) && typeof range[0] === "number" && typeof range[1] === "number";
+var safeParseDocument = (yamlText) => {
+	try {
+		return parseDocument(yamlText);
+	} catch {
+		return null;
+	}
+};
+/**
+* Finds the byte range (offset) in the YAML text corresponding to a JSON path.
+* Given a YAML string and a path (array of segments), parses the document and walks
+* down the tree to find the target node or key, returning its start and end offsets.
+* Will prefer to highlight the "key" part for map entries, to avoid highlighting the value which
+* might be offset due to block structure.
+*
+* @param yamlText The YAML string
+* @param path An array representing the path to traverse
+* @returns The byte offsets in the YAML string of the node (or null if not found)
+*/
+var getYamlNodeRangeFromPath = (yamlText, path) => {
+	const doc = safeParseDocument(yamlText);
+	if (!doc) return null;
+	let current = doc.contents;
+	let lastPair = null;
+	for (const segment of path) {
+		if (isMap(current)) {
+			const key = String(segment);
+			const pair = current.items.find((p) => {
+				if (!isPair(p)) return false;
+				const pairKey = p.key;
+				return isScalar(pairKey) ? String(pairKey.value) === key : String(pairKey) === key;
+			});
+			if (!pair || !isPair(pair)) return null;
+			lastPair = pair;
+			current = pair.value;
+			continue;
+		}
+		if (isSeq(current)) {
+			const index = typeof segment === "number" ? segment : Number.parseInt(String(segment), 10);
+			if (!Number.isFinite(index) || index < 0 || index >= current.items.length) return null;
+			lastPair = null;
+			current = current.items[index];
+			continue;
+		}
+		return null;
+	}
+	if (lastPair && isPair(lastPair)) {
+		const keyRange = lastPair.key?.range;
+		const valueRange = lastPair.value?.range;
+		if (!isValidYamlRange(keyRange)) return null;
+		const startOffset = Math.max(0, keyRange[0]);
+		return {
+			startOffset,
+			endOffset: isValidYamlRange(valueRange) ? Math.max(startOffset, valueRange[1]) : Math.max(startOffset, keyRange[1])
+		};
+	}
+	const nodeRange = current?.range;
+	if (!isValidYamlRange(nodeRange)) return null;
+	const startOffset = Math.max(0, nodeRange[0]);
+	return {
+		startOffset,
+		endOffset: Math.max(startOffset, nodeRange[1])
+	};
+};
+//#endregion
+export { getYamlNodeRangeFromPath };
+
+//# sourceMappingURL=get-yaml-node-range-from-path.js.map

package/dist/v2/features/editor/helpers/yaml/get-yaml-node-range-from-path.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"get-yaml-node-range-from-path.js","names":[],"sources":["../../../../../../src/v2/features/editor/helpers/yaml/get-yaml-node-range-from-path.ts"],"sourcesContent":["import { isMap, isPair, isScalar, isSeq, parseDocument } from 'yaml'\n\nimport type { Path } from '@/v2/features/editor/helpers/model'\n\ntype YamlNodeRange = {\n  startOffset: number\n  endOffset: number\n}\n\nconst isValidYamlRange = (range: unknown): range is readonly [number, number, ...unknown[]] =>\n  Array.isArray(range) && typeof range[0] === 'number' && typeof range[1] === 'number'\n\nconst safeParseDocument = (yamlText: string) => {\n  try {\n    return parseDocument(yamlText)\n  } catch {\n    return null\n  }\n}\n\n/**\n * Finds the byte range (offset) in the YAML text corresponding to a JSON path.\n * Given a YAML string and a path (array of segments), parses the document and walks\n * down the tree to find the target node or key, returning its start and end offsets.\n * Will prefer to highlight the \"key\" part for map entries, to avoid highlighting the value which\n * might be offset due to block structure.\n *\n * @param yamlText The YAML string\n * @param path An array representing the path to traverse\n * @returns The byte offsets in the YAML string of the node (or null if not found)\n */\nexport const getYamlNodeRangeFromPath = (yamlText: string, path: Path): YamlNodeRange | null => {\n  const doc = safeParseDocument(yamlText)\n  if (!doc) {\n    return null\n  }\n\n  let current: unknown = doc.contents\n  let lastPair: unknown = null\n\n  // Traverse the path, descending through maps and sequences as needed.\n  for (const segment of path) {\n    if (isMap(current)) {\n      const key = String(segment)\n      const pair = current.items.find((p) => {\n        if (!isPair(p)) {\n          return false\n        }\n        const pairKey = p.key\n        return isScalar(pairKey) ? String(pairKey.value) === key : String(pairKey) === key\n      })\n\n      if (!pair || !isPair(pair)) {\n        // Path segment does not exist in this map\n        return null\n      }\n\n      lastPair = pair\n      current = pair.value\n      continue\n    }\n\n    if (isSeq(current)) {\n      // Ensure we have a valid integer index for arrays\n      const index = typeof segment === 'number' ? segment : Number.parseInt(String(segment), 10)\n      if (!Number.isFinite(index) || index < 0 || index >= current.items.length) {\n        return null\n      }\n\n      lastPair = null\n      current = current.items[index]\n      continue\n    }\n\n    // If current isn't traversable\n    return null\n  }\n\n  // Prefer highlighting the key line for map entries (avoids being off-by-one line for block values).\n  if (lastPair && isPair(lastPair)) {\n    const keyRange = (lastPair.key as { range?: unknown } | null)?.range\n    const valueRange = (lastPair.value as { range?: unknown } | null)?.range\n\n    if (!isValidYamlRange(keyRange)) {\n      return null\n    }\n\n    const startOffset = Math.max(0, keyRange[0])\n    const endOffset = isValidYamlRange(valueRange)\n      ? Math.max(startOffset, valueRange[1])\n      : Math.max(startOffset, keyRange[1])\n\n    return { startOffset, endOffset }\n  }\n\n  // For non-map entries, just use the node's own range property if it exists.\n  const nodeRange = (current as { range?: unknown } | null)?.range\n  if (!isValidYamlRange(nodeRange)) {\n    return null\n  }\n\n  const startOffset = Math.max(0, nodeRange[0])\n  const endOffset = Math.max(startOffset, nodeRange[1])\n\n  return { startOffset, endOffset }\n}\n"],"mappings":";;AASA,IAAM,oBAAoB,UACxB,MAAM,QAAQ,MAAM,IAAI,OAAO,MAAM,OAAO,YAAY,OAAO,MAAM,OAAO;AAE9E,IAAM,qBAAqB,aAAqB;AAC9C,KAAI;AACF,SAAO,cAAc,SAAS;SACxB;AACN,SAAO;;;;;;;;;;;;;;AAeX,IAAa,4BAA4B,UAAkB,SAAqC;CAC9F,MAAM,MAAM,kBAAkB,SAAS;AACvC,KAAI,CAAC,IACH,QAAO;CAGT,IAAI,UAAmB,IAAI;CAC3B,IAAI,WAAoB;AAGxB,MAAK,MAAM,WAAW,MAAM;AAC1B,MAAI,MAAM,QAAQ,EAAE;GAClB,MAAM,MAAM,OAAO,QAAQ;GAC3B,MAAM,OAAO,QAAQ,MAAM,MAAM,MAAM;AACrC,QAAI,CAAC,OAAO,EAAE,CACZ,QAAO;IAET,MAAM,UAAU,EAAE;AAClB,WAAO,SAAS,QAAQ,GAAG,OAAO,QAAQ,MAAM,KAAK,MAAM,OAAO,QAAQ,KAAK;KAC/E;AAEF,OAAI,CAAC,QAAQ,CAAC,OAAO,KAAK,CAExB,QAAO;AAGT,cAAW;AACX,aAAU,KAAK;AACf;;AAGF,MAAI,MAAM,QAAQ,EAAE;GAElB,MAAM,QAAQ,OAAO,YAAY,WAAW,UAAU,OAAO,SAAS,OAAO,QAAQ,EAAE,GAAG;AAC1F,OAAI,CAAC,OAAO,SAAS,MAAM,IAAI,QAAQ,KAAK,SAAS,QAAQ,MAAM,OACjE,QAAO;AAGT,cAAW;AACX,aAAU,QAAQ,MAAM;AACxB;;AAIF,SAAO;;AAIT,KAAI,YAAY,OAAO,SAAS,EAAE;EAChC,MAAM,WAAY,SAAS,KAAoC;EAC/D,MAAM,aAAc,SAAS,OAAsC;AAEnE,MAAI,CAAC,iBAAiB,SAAS,CAC7B,QAAO;EAGT,MAAM,cAAc,KAAK,IAAI,GAAG,SAAS,GAAG;AAK5C,SAAO;GAAE;GAAa,WAJJ,iBAAiB,WAAW,GAC1C,KAAK,IAAI,aAAa,WAAW,GAAG,GACpC,KAAK,IAAI,aAAa,SAAS,GAAG;GAEL;;CAInC,MAAM,YAAa,SAAwC;AAC3D,KAAI,CAAC,iBAAiB,UAAU,CAC9B,QAAO;CAGT,MAAM,cAAc,KAAK,IAAI,GAAG,UAAU,GAAG;AAG7C,QAAO;EAAE;EAAa,WAFJ,KAAK,IAAI,aAAa,UAAU,GAAG;EAEpB"}

package/dist/v2/features/editor/hooks/use-editor-markers.js

@@ -0,0 +1,37 @@
+import { onBeforeUnmount, onMounted, ref, toValue, watch } from "vue";
+import * as monaco from "monaco-editor/esm/vs/editor/editor.api.js";
+//#region src/v2/features/editor/hooks/use-editor-markers.ts
+var useEditorMarkers = (editorRef) => {
+	const markers = ref([]);
+	let dispose = null;
+	const retryTimeouts = [];
+	const updateMarkers = () => {
+		const resource = toValue(editorRef)?.getModel()?.uri;
+		if (!resource) {
+			markers.value = [];
+			return;
+		}
+		markers.value = monaco.editor.getModelMarkers({}).filter((marker) => marker.resource.toString() === resource.toString());
+	};
+	const scheduleMarkerReads = () => {
+		retryTimeouts.push(setTimeout(updateMarkers, 0), setTimeout(updateMarkers, 80), setTimeout(updateMarkers, 220));
+	};
+	onMounted(() => {
+		dispose = monaco.editor.onDidChangeMarkers(() => {
+			scheduleMarkerReads();
+		});
+		scheduleMarkerReads();
+	});
+	onBeforeUnmount(() => {
+		dispose?.dispose();
+		retryTimeouts.forEach((timeout) => clearTimeout(timeout));
+	});
+	watch(() => toValue(editorRef)?.getModel()?.uri?.toString(), () => {
+		scheduleMarkerReads();
+	}, { immediate: true });
+	return { markers };
+};
+//#endregion
+export { useEditorMarkers };
+
+//# sourceMappingURL=use-editor-markers.js.map

package/dist/v2/features/editor/hooks/use-editor-markers.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-editor-markers.js","names":[],"sources":["../../../../../src/v2/features/editor/hooks/use-editor-markers.ts"],"sourcesContent":["import * as monaco from 'monaco-editor/esm/vs/editor/editor.api.js'\nimport { type MaybeRefOrGetter, onBeforeUnmount, onMounted, ref, toValue, watch } from 'vue'\n\nexport const useEditorMarkers = (editorRef: MaybeRefOrGetter<monaco.editor.IStandaloneCodeEditor | undefined>) => {\n  const markers = ref<monaco.editor.IMarker[]>([])\n\n  let dispose: monaco.IDisposable | null = null\n  const retryTimeouts: ReturnType<typeof setTimeout>[] = []\n\n  const updateMarkers = () => {\n    const editor = toValue(editorRef)\n    const resource = editor?.getModel()?.uri\n\n    if (!resource) {\n      markers.value = []\n      return\n    }\n\n    markers.value = monaco.editor\n      .getModelMarkers({})\n      .filter((marker) => marker.resource.toString() === resource.toString())\n  }\n\n  const scheduleMarkerReads = () => {\n    retryTimeouts.push(setTimeout(updateMarkers, 0), setTimeout(updateMarkers, 80), setTimeout(updateMarkers, 220))\n  }\n\n  onMounted(() => {\n    dispose = monaco.editor.onDidChangeMarkers(() => {\n      scheduleMarkerReads()\n    })\n\n    // initial fetch\n    scheduleMarkerReads()\n  })\n\n  onBeforeUnmount(() => {\n    dispose?.dispose()\n    retryTimeouts.forEach((timeout) => clearTimeout(timeout))\n  })\n\n  watch(\n    () => toValue(editorRef)?.getModel()?.uri?.toString(),\n    () => {\n      scheduleMarkerReads()\n    },\n    { immediate: true },\n  )\n\n  return {\n    markers,\n  }\n}\n"],"mappings":";;;AAGA,IAAa,oBAAoB,cAAiF;CAChH,MAAM,UAAU,IAA6B,EAAE,CAAC;CAEhD,IAAI,UAAqC;CACzC,MAAM,gBAAiD,EAAE;CAEzD,MAAM,sBAAsB;EAE1B,MAAM,WADS,QAAQ,UAAU,EACR,UAAU,EAAE;AAErC,MAAI,CAAC,UAAU;AACb,WAAQ,QAAQ,EAAE;AAClB;;AAGF,UAAQ,QAAQ,OAAO,OACpB,gBAAgB,EAAE,CAAC,CACnB,QAAQ,WAAW,OAAO,SAAS,UAAU,KAAK,SAAS,UAAU,CAAC;;CAG3E,MAAM,4BAA4B;AAChC,gBAAc,KAAK,WAAW,eAAe,EAAE,EAAE,WAAW,eAAe,GAAG,EAAE,WAAW,eAAe,IAAI,CAAC;;AAGjH,iBAAgB;AACd,YAAU,OAAO,OAAO,yBAAyB;AAC/C,wBAAqB;IACrB;AAGF,uBAAqB;GACrB;AAEF,uBAAsB;AACpB,WAAS,SAAS;AAClB,gBAAc,SAAS,YAAY,aAAa,QAAQ,CAAC;GACzD;AAEF,aACQ,QAAQ,UAAU,EAAE,UAAU,EAAE,KAAK,UAAU,QAC/C;AACJ,uBAAqB;IAEvB,EAAE,WAAW,MAAM,CACpB;AAED,QAAO,EACL,SACD"}