@parallelworks/ui 0.19.1 → 0.21.0

package/dist/editor/workers.d.ts

@@ -4,3 +4,8 @@
  * calls this on first load only when nothing is configured.
  */
 export declare function setupMonacoWorkers(): void;
+/**
+ * Starts the YAML language server. It is not a Monaco worker, so a host's own
+ * MonacoEnvironment never has to provide it.
+ */
+export declare function createYamlWorker(): Worker;

package/dist/editor/workers.js

@@ -2,17 +2,12 @@
 var monacoEnvironment = { getWorker(_moduleId, label) {
 	if (label === "json") return new Worker(new URL(
 		/* @vite-ignore */
-		"/assets/json.worker-D8bJ92nw.js",
-		"" + import.meta.url
-	), { type: "module" });
-	if (label === "yaml") return new Worker(new URL(
-		/* @vite-ignore */
-		"/assets/yaml.worker-C4gyGAko.js",
+		new URL("../assets/json.worker-Dqgjpq9F.js", import.meta.url).href,
 		"" + import.meta.url
 	), { type: "module" });
 	return new Worker(new URL(
 		/* @vite-ignore */
-		"/assets/editor.worker-BmHUIVG4.js",
+		new URL("../assets/editor.worker-DfmPPyOL.js", import.meta.url).href,
 		"" + import.meta.url
 	), { type: "module" });
 } };
@@ -25,5 +20,16 @@ function setupMonacoWorkers() {
 	if (window.MonacoEnvironment) return;
 	window.MonacoEnvironment = monacoEnvironment;
 }
+/**
+* Starts the YAML language server. It is not a Monaco worker, so a host's own
+* MonacoEnvironment never has to provide it.
+*/
+function createYamlWorker() {
+	return new Worker(new URL(
+		/* @vite-ignore */
+		new URL("../assets/yaml.worker-DLx0whrM.js", import.meta.url).href,
+		"" + import.meta.url
+	), { type: "module" });
+}
 //#endregion
-export { setupMonacoWorkers };
+export { createYamlWorker, setupMonacoWorkers };

package/dist/editor/yaml.d.ts

@@ -1,4 +1,12 @@
-import type { SchemasSettings } from 'monaco-yaml';
+/** A JSON schema for the YAML models whose URI matches one of `fileMatch`. */
+export interface SchemasSettings {
+    /** Identifies the schema; fetched from here when `schema` is not given. */
+    uri: string;
+    /** Globs matched against model URIs, such as `**\/workflow.yaml`. */
+    fileMatch?: string[];
+    /** The schema itself, used instead of fetching `uri`. */
+    schema?: object;
+}
 /** Adds JSON schemas that validate and complete YAML models whose URI matches. */
 export declare function configureEditorYaml(added: SchemasSettings[]): void;
 /** Lets the loaded editor pick up schemas added before or after it loads. */

package/dist/editor/yaml.worker.d.ts

@@ -0,0 +1 @@
+import 'yaml-language-server/lib/esm/webworker/yamlServerMain';

package/dist/editor/yamlLanguage.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Starts the YAML language server and connects every yaml model to it. Runs
+ * once per page and is never torn down: a per-editor lifecycle let navigation
+ * stop the service, killing suggestions until reload.
+ */
+export declare function ensureYamlLanguage(): void;

package/dist/editor/yamlLanguage.js

@@ -0,0 +1,312 @@
+import { createYamlWorker } from "./workers.js";
+import { onYamlSchemas } from "./yaml.js";
+import * as monaco from "monaco-editor";
+//#region src/editor/yamlLanguage.ts
+var LANGUAGE_ID = "yaml";
+var MARKER_OWNER = "yaml";
+var YAML_SETTINGS = {
+	validate: true,
+	hover: true,
+	completion: true,
+	format: { enable: true },
+	schemaStore: { enable: false }
+};
+/** JSON-RPC over postMessage, the transport the server's web worker build expects. */
+var WorkerConnection = class {
+	nextId = 0;
+	pending = /* @__PURE__ */ new Map();
+	notificationHandlers = /* @__PURE__ */ new Map();
+	worker;
+	onRequest;
+	constructor(worker, onRequest) {
+		this.worker = worker;
+		this.onRequest = onRequest;
+		worker.addEventListener("message", (event) => this.receive(event.data));
+	}
+	request(method, params, token) {
+		const id = this.nextId++;
+		const result = new Promise((resolve, reject) => {
+			this.pending.set(id, {
+				resolve,
+				reject
+			});
+		});
+		this.send({
+			jsonrpc: "2.0",
+			id,
+			method,
+			params
+		});
+		token?.onCancellationRequested(() => this.notify("$/cancelRequest", { id }));
+		return result;
+	}
+	notify(method, params) {
+		this.send({
+			jsonrpc: "2.0",
+			method,
+			params
+		});
+	}
+	onNotification(method, handler) {
+		this.notificationHandlers.set(method, handler);
+	}
+	send(message) {
+		this.worker.postMessage(message);
+	}
+	receive(message) {
+		if (message.method === void 0) {
+			const waiter = typeof message.id === "number" ? this.pending.get(message.id) : void 0;
+			if (!waiter || typeof message.id !== "number") return;
+			this.pending.delete(message.id);
+			if (message.error) waiter.reject(new Error(message.error.message));
+			else waiter.resolve(message.result);
+			return;
+		}
+		if (message.id === void 0) {
+			this.notificationHandlers.get(message.method)?.(message.params);
+			return;
+		}
+		Promise.resolve().then(() => this.onRequest(message.method ?? "", message.params)).then((result) => this.send({
+			jsonrpc: "2.0",
+			id: message.id ?? null,
+			result: result ?? null
+		}), (error) => this.send({
+			jsonrpc: "2.0",
+			id: message.id ?? null,
+			error: {
+				code: -32603,
+				message: String(error)
+			}
+		}));
+	}
+};
+function toRange(range) {
+	return {
+		startLineNumber: range.start.line + 1,
+		startColumn: range.start.character + 1,
+		endLineNumber: range.end.line + 1,
+		endColumn: range.end.character + 1
+	};
+}
+function toPosition(position) {
+	return {
+		line: position.lineNumber - 1,
+		character: position.column - 1
+	};
+}
+function toMarkdown(content) {
+	if (typeof content === "string") return { value: content };
+	if ("kind" in content) return { value: content.value };
+	return { value: `\`\`\`${content.language}\n${content.value}\n\`\`\`` };
+}
+var SEVERITY = {
+	1: monaco.MarkerSeverity.Error,
+	2: monaco.MarkerSeverity.Warning,
+	3: monaco.MarkerSeverity.Info,
+	4: monaco.MarkerSeverity.Hint
+};
+function toMarker(diagnostic) {
+	return {
+		...toRange(diagnostic.range),
+		severity: SEVERITY[diagnostic.severity ?? 1] ?? monaco.MarkerSeverity.Error,
+		message: diagnostic.message,
+		...diagnostic.code === void 0 ? {} : { code: String(diagnostic.code) },
+		...diagnostic.source === void 0 ? {} : { source: diagnostic.source }
+	};
+}
+var KIND = monaco.languages.CompletionItemKind;
+var COMPLETION_KIND = {
+	1: KIND.Text,
+	2: KIND.Method,
+	3: KIND.Function,
+	4: KIND.Constructor,
+	5: KIND.Field,
+	6: KIND.Variable,
+	7: KIND.Class,
+	8: KIND.Interface,
+	9: KIND.Module,
+	10: KIND.Property,
+	11: KIND.Unit,
+	12: KIND.Value,
+	13: KIND.Enum,
+	14: KIND.Keyword,
+	15: KIND.Snippet,
+	16: KIND.Color,
+	17: KIND.File,
+	18: KIND.Reference,
+	19: KIND.Folder,
+	20: KIND.EnumMember,
+	21: KIND.Constant,
+	22: KIND.Struct,
+	23: KIND.Event,
+	24: KIND.Operator,
+	25: KIND.TypeParameter
+};
+function toCompletion(item, defaultRange) {
+	const edit = item.textEdit;
+	let range = defaultRange;
+	if (edit && "range" in edit) range = toRange(edit.range);
+	else if (edit) range = {
+		insert: toRange(edit.insert),
+		replace: toRange(edit.replace)
+	};
+	return {
+		label: item.label,
+		kind: COMPLETION_KIND[item.kind ?? 1] ?? KIND.Text,
+		insertText: edit?.newText ?? item.insertText ?? item.label,
+		range,
+		...item.insertTextFormat === 2 ? { insertTextRules: monaco.languages.CompletionItemInsertTextRule.InsertAsSnippet } : {},
+		...item.detail === void 0 ? {} : { detail: item.detail },
+		...item.documentation === void 0 ? {} : { documentation: toMarkdown(item.documentation) },
+		...item.sortText === void 0 ? {} : { sortText: item.sortText },
+		...item.filterText === void 0 ? {} : { filterText: item.filterText },
+		...item.commitCharacters === void 0 ? {} : { commitCharacters: item.commitCharacters },
+		...item.additionalTextEdits === void 0 ? {} : { additionalTextEdits: item.additionalTextEdits.map((e) => ({
+			range: toRange(e.range),
+			text: e.newText
+		})) },
+		...item.command === void 0 ? {} : { command: {
+			id: item.command.command,
+			title: item.command.title,
+			...item.command.arguments === void 0 ? {} : { arguments: item.command.arguments }
+		} }
+	};
+}
+function toEdits(edits) {
+	return (edits ?? []).map((edit) => ({
+		range: toRange(edit.range),
+		text: edit.newText
+	}));
+}
+function answerServer(method, params) {
+	if (method === "workspace/configuration") {
+		const { items } = params;
+		return items.map((item) => item.section === "yaml" ? YAML_SETTINGS : null);
+	}
+	return null;
+}
+function startYamlLanguage() {
+	const worker = createYamlWorker();
+	worker.postMessage({});
+	const connection = new WorkerConnection(worker, answerServer);
+	const open = /* @__PURE__ */ new Map();
+	const ready = connection.request("initialize", {
+		processId: null,
+		rootUri: null,
+		capabilities: {
+			workspace: { configuration: true },
+			textDocument: {
+				synchronization: {},
+				completion: { completionItem: {
+					snippetSupport: true,
+					insertReplaceSupport: true,
+					documentationFormat: ["markdown", "plaintext"]
+				} },
+				hover: { contentFormat: ["markdown", "plaintext"] },
+				publishDiagnostics: {}
+			}
+		}
+	}).then(() => {
+		connection.notify("initialized", {});
+		connection.notify("workspace/didChangeConfiguration", { settings: null });
+	});
+	onYamlSchemas((schemas) => {
+		ready.then(() => connection.notify("json/schemaAssociations", [schemas]));
+	});
+	connection.onNotification("textDocument/publishDiagnostics", (params) => {
+		const { uri, diagnostics } = params;
+		const model = open.get(uri);
+		if (model && !model.isDisposed()) monaco.editor.setModelMarkers(model, MARKER_OWNER, diagnostics.map(toMarker));
+	});
+	function close(uri, model) {
+		open.delete(uri);
+		ready.then(() => connection.notify("textDocument/didClose", { textDocument: { uri } }));
+		if (!model.isDisposed()) monaco.editor.setModelMarkers(model, MARKER_OWNER, []);
+	}
+	function track(model) {
+		const uri = model.uri.toString();
+		const sync = () => {
+			const isYaml = model.getLanguageId() === LANGUAGE_ID;
+			if (isYaml && !open.has(uri)) {
+				open.set(uri, model);
+				const textDocument = {
+					uri,
+					languageId: LANGUAGE_ID,
+					version: model.getVersionId(),
+					text: model.getValue()
+				};
+				ready.then(() => connection.notify("textDocument/didOpen", { textDocument }));
+			} else if (!isYaml && open.has(uri)) close(uri, model);
+		};
+		model.onDidChangeLanguage(sync);
+		model.onDidChangeContent(() => {
+			if (!open.has(uri)) return;
+			const params = {
+				textDocument: {
+					uri,
+					version: model.getVersionId()
+				},
+				contentChanges: [{ text: model.getValue() }]
+			};
+			ready.then(() => connection.notify("textDocument/didChange", params));
+		});
+		model.onWillDispose(() => {
+			if (open.get(uri) === model) close(uri, model);
+		});
+		sync();
+	}
+	for (const model of monaco.editor.getModels()) track(model);
+	monaco.editor.onDidCreateModel(track);
+	async function request(method, model, params, token) {
+		await ready;
+		return connection.request(method, {
+			textDocument: { uri: model.uri.toString() },
+			...params
+		}, token);
+	}
+	monaco.languages.registerCompletionItemProvider(LANGUAGE_ID, {
+		triggerCharacters: [" ", ":"],
+		async provideCompletionItems(model, position, _context, token) {
+			const result = await request("textDocument/completion", model, { position: toPosition(position) }, token);
+			const word = model.getWordUntilPosition(position);
+			const defaultRange = {
+				startLineNumber: position.lineNumber,
+				startColumn: word.startColumn,
+				endLineNumber: position.lineNumber,
+				endColumn: word.endColumn
+			};
+			const items = Array.isArray(result) ? result : result?.items ?? [];
+			return {
+				incomplete: !Array.isArray(result) && Boolean(result?.isIncomplete),
+				suggestions: items.map((item) => toCompletion(item, defaultRange))
+			};
+		}
+	});
+	monaco.languages.registerHoverProvider(LANGUAGE_ID, { async provideHover(model, position, token) {
+		const hover = await request("textDocument/hover", model, { position: toPosition(position) }, token);
+		if (!hover) return null;
+		return {
+			contents: (Array.isArray(hover.contents) ? hover.contents : [hover.contents]).map(toMarkdown),
+			...hover.range === void 0 ? {} : { range: toRange(hover.range) }
+		};
+	} });
+	monaco.languages.registerDocumentFormattingEditProvider(LANGUAGE_ID, { async provideDocumentFormattingEdits(model, options, token) {
+		return toEdits(await request("textDocument/formatting", model, { options: {
+			tabSize: options.tabSize,
+			insertSpaces: options.insertSpaces
+		} }, token));
+	} });
+}
+var started = false;
+/**
+* Starts the YAML language server and connects every yaml model to it. Runs
+* once per page and is never torn down: a per-editor lifecycle let navigation
+* stop the service, killing suggestions until reload.
+*/
+function ensureYamlLanguage() {
+	if (started) return;
+	started = true;
+	startYamlLanguage();
+}
+//#endregion
+export { ensureYamlLanguage };