@graphql-hive/laboratory/dist/graphqlMode-Db7_RZsG.js

[Hive](https://the-guild.dev/graphql/hive) is a fully open-source schema registry, analytics, metrics and gateway for [GraphQL federation](https://the-guild.dev/graphql/hive/federation) and other GraphQL APIs.

import { f as Uri, h as languages, p as editor } from "./editor.api-DPgI1LYm.js";
import { A as isIntrospectionType, At as inspect, Bt as invariant, Ct as print, G as isSpecifiedScalarType, It as Kind, N as DEFAULT_DEPRECATION_REASON, Pt as isPrintableAsBlockString, R as isSpecifiedDirective, bt as isScalarType, ft as isInterfaceType, i as CompletionItemKind, j as astFromValue, lt as isEnumType, o as buildASTSchema, ut as isInputObjectType, vt as isObjectType, xt as isUnionType } from "./monaco-editor-CQb_QZSU.js";
import "./monaco.contribution-BUcZa-0g.js";
function printSchema(p) {
	return printFilteredSchema(p, (p) => !isSpecifiedDirective(p), isDefinedType);
}
function isDefinedType(p) {
	return !isSpecifiedScalarType(p) && !isIntrospectionType(p);
}
function printFilteredSchema(p, H, U) {
	let W = p.getDirectives().filter(H), G = Object.values(p.getTypeMap()).filter(U);
	return [
		printSchemaDefinition(p),
		...W.map((p) => printDirective(p)),
		...G.map((p) => printType(p))
	].filter(Boolean).join("\n\n");
}
function printSchemaDefinition(p) {
	if (p.description == null && isSchemaOfCommonNames(p)) return;
	let H = [], U = p.getQueryType();
	U && H.push(`  query: ${U.name}`);
	let W = p.getMutationType();
	W && H.push(`  mutation: ${W.name}`);
	let G = p.getSubscriptionType();
	return G && H.push(`  subscription: ${G.name}`), printDescription(p) + `schema {\n${H.join("\n")}\n}`;
}
function isSchemaOfCommonNames(p) {
	let H = p.getQueryType();
	if (H && H.name !== "Query") return !1;
	let U = p.getMutationType();
	if (U && U.name !== "Mutation") return !1;
	let W = p.getSubscriptionType();
	return !(W && W.name !== "Subscription");
}
function printType(p) {
	if (isScalarType(p)) return printScalar(p);
	if (isObjectType(p)) return printObject(p);
	if (isInterfaceType(p)) return printInterface(p);
	if (isUnionType(p)) return printUnion(p);
	if (isEnumType(p)) return printEnum(p);
	if (isInputObjectType(p)) return printInputObject(p);
	/* c8 ignore next 3 */
	invariant(!1, "Unexpected type: " + inspect(p));
}
function printScalar(p) {
	return printDescription(p) + `scalar ${p.name}` + printSpecifiedByURL(p);
}
function printImplementedInterfaces(p) {
	let H = p.getInterfaces();
	return H.length ? " implements " + H.map((p) => p.name).join(" & ") : "";
}
function printObject(p) {
	return printDescription(p) + `type ${p.name}` + printImplementedInterfaces(p) + printFields(p);
}
function printInterface(p) {
	return printDescription(p) + `interface ${p.name}` + printImplementedInterfaces(p) + printFields(p);
}
function printUnion(p) {
	let H = p.getTypes(), U = H.length ? " = " + H.join(" | ") : "";
	return printDescription(p) + "union " + p.name + U;
}
function printEnum(p) {
	let H = p.getValues().map((p, H) => printDescription(p, "  ", !H) + "  " + p.name + printDeprecated(p.deprecationReason));
	return printDescription(p) + `enum ${p.name}` + printBlock(H);
}
function printInputObject(p) {
	let H = Object.values(p.getFields()).map((p, H) => printDescription(p, "  ", !H) + "  " + printInputValue(p));
	return printDescription(p) + `input ${p.name}` + (p.isOneOf ? " @oneOf" : "") + printBlock(H);
}
function printFields(p) {
	let H = Object.values(p.getFields()).map((p, H) => printDescription(p, "  ", !H) + "  " + p.name + printArgs(p.args, "  ") + ": " + String(p.type) + printDeprecated(p.deprecationReason));
	return printBlock(H);
}
function printBlock(p) {
	return p.length === 0 ? "" : " {\n" + p.join("\n") + "\n}";
}
function printArgs(p, H = "") {
	return p.length === 0 ? "" : p.every((p) => !p.description) ? "(" + p.map(printInputValue).join(", ") + ")" : "(\n" + p.map((p, U) => printDescription(p, "  " + H, !U) + "  " + H + printInputValue(p)).join("\n") + "\n" + H + ")";
}
function printInputValue(p) {
	let H = astFromValue(p.defaultValue, p.type), U = p.name + ": " + String(p.type);
	return H && (U += ` = ${print(H)}`), U + printDeprecated(p.deprecationReason);
}
function printDirective(p) {
	return printDescription(p) + "directive @" + p.name + printArgs(p.args) + printDeprecated(p.deprecationReason) + (p.isRepeatable ? " repeatable" : "") + " on " + p.locations.join(" | ");
}
function printDeprecated(p) {
	return p == null ? "" : p === "No longer supported" ? " @deprecated" : ` @deprecated(reason: ${print({
		kind: Kind.STRING,
		value: p
	})})`;
}
function printSpecifiedByURL(p) {
	return p.specifiedByURL == null ? "" : ` @specifiedBy(url: ${print({
		kind: Kind.STRING,
		value: p.specifiedByURL
	})})`;
}
function printDescription(p, H = "", U = !0) {
	let { description: W } = p;
	if (W == null) return "";
	let G = print({
		kind: Kind.STRING,
		value: W,
		block: isPrintableAsBlockString(W)
	});
	return (H && !U ? "\n" + H : H) + G.replace(/\n/g, "\n" + H) + "\n";
}
const getModelLanguageId = (p) => "getModeId" in p ? p.getModeId() : p.getLanguageId(), getStringSchema = (p) => {
	let { schema: H, documentAST: U, introspectionJSON: W, introspectionJSONString: G, documentString: K,...q } = p;
	if (H) return {
		...q,
		documentString: printSchema(H)
	};
	if (G) return {
		...q,
		introspectionJSONString: G
	};
	if (K) return {
		...q,
		documentString: K
	};
	if (W) return {
		...q,
		introspectionJSONString: JSON.stringify(W)
	};
	if (U) {
		let p = buildASTSchema(U, q.buildSchemaOptions);
		return {
			...q,
			documentString: printSchema(p)
		};
	}
	throw Error("No schema supplied");
};
var STOP_WHEN_IDLE_FOR = 120 * 1e3, WorkerManager = class {
	_defaults;
	_idleCheckInterval;
	_lastUsedTime = 0;
	_configChangeListener;
	_worker = null;
	_client = null;
	constructor(p) {
		this._defaults = p, this._idleCheckInterval = window.setInterval(() => this._checkIfIdle(), 30 * 1e3), this._configChangeListener = this._defaults.onDidChange(() => {
			this._stopWorker();
		});
	}
	_stopWorker() {
		this._worker &&= (this._worker.dispose(), null), this._client = null;
	}
	dispose() {
		clearInterval(this._idleCheckInterval), this._configChangeListener.dispose(), this._stopWorker();
	}
	_checkIfIdle() {
		this._worker && Date.now() - this._lastUsedTime > STOP_WHEN_IDLE_FOR && this._stopWorker();
	}
	async _getClient() {
		if (this._lastUsedTime = Date.now(), !this._client && !this._worker) try {
			let { languageId: p, formattingOptions: H, schemas: W, externalFragmentDefinitions: G, completionSettings: K } = this._defaults;
			this._worker = editor.createWebWorker({
				moduleId: "monaco-graphql/esm/GraphQLWorker.js",
				label: p,
				createData: {
					languageId: p,
					formattingOptions: H,
					languageConfig: {
						schemas: W?.map(getStringSchema),
						externalFragmentDefinitions: G,
						fillLeafsOnComplete: K.__experimental__fillLeafsOnComplete
					}
				}
			}), this._client = this._worker.getProxy();
		} catch (p) {
			console.error("error loading worker", p);
		}
		return this._client;
	}
	async getLanguageServiceWorker(...p) {
		let H = await this._getClient();
		return await this._worker.withSyncedResources(p), H;
	}
}, DiagnosticsAdapter = class {
	defaults;
	_worker;
	_disposables = [];
	_listener = Object.create(null);
	constructor(p, H) {
		this.defaults = p, this._worker = H, this._worker = H;
		let W, G = (H) => {
			let U = getModelLanguageId(H);
			if (U !== this.defaults.languageId) return;
			let G = H.uri.toString(), K = p.diagnosticSettings.validateVariablesJSON?.[G];
			W = setTimeout(() => {
				this._doValidate(H.uri, U, K);
			}, 400), this._listener[G] = H.onDidChangeContent(() => {
				clearTimeout(W), W = setTimeout(() => {
					this._doValidate(H.uri, U, K);
				}, 400);
			});
		}, K = (p) => {
			editor.setModelMarkers(p, this.defaults.languageId, []);
			let H = p.uri.toString(), W = this._listener[H];
			W && (W.dispose(), delete this._listener[H]);
		};
		this._disposables.push(editor.onDidCreateModel(G), { dispose() {
			clearTimeout(W);
		} }, editor.onWillDisposeModel((p) => {
			K(p);
		}), editor.onDidChangeModelLanguage((p) => {
			K(p.model), G(p.model);
		}), { dispose: () => {
			for (let p of Object.values(this._listener)) p.dispose();
		} }, p.onDidChange(() => {
			for (let p of editor.getModels()) getModelLanguageId(p) === this.defaults.languageId && (K(p), G(p));
		}));
		for (let p of editor.getModels()) getModelLanguageId(p) === this.defaults.languageId && G(p);
	}
	dispose() {
		for (let p of this._disposables) p.dispose();
		this._disposables = [];
	}
	async _doValidate(W, G, K) {
		let q = await this._worker(W);
		if (!q) return;
		let J = await q.doValidation(W.toString());
		if (editor.setModelMarkers(editor.getModel(W), G, J), K) {
			if (await import("./monaco.contribution-pnEHc2s_.js"), !K.length) throw Error("No variables URI strings provided to validate");
			let U = await q.doGetVariablesJSONSchema(W.toString());
			if (!U) return;
			let G = Uri.file(K[0].replace(".json", "-schema.json")).toString(), J = {
				uri: G,
				schema: U,
				fileMatch: K
			}, Y = languages.json.jsonDefaults.diagnosticsOptions.schemas?.filter((p) => p.uri !== G) || [];
			languages.json.jsonDefaults.setDiagnosticsOptions({
				schemaValidation: "error",
				validate: !0,
				...this.defaults.diagnosticSettings.jsonDiagnosticSettings,
				schemas: [...Y, J],
				enableSchemaRequest: !1
			});
		}
	}
}, mKind = languages.CompletionItemKind, kindMap = {
	[CompletionItemKind.Text]: mKind.Text,
	[CompletionItemKind.Method]: mKind.Method,
	[CompletionItemKind.Function]: mKind.Function,
	[CompletionItemKind.Constructor]: mKind.Constructor,
	[CompletionItemKind.Field]: mKind.Field,
	[CompletionItemKind.Variable]: mKind.Variable,
	[CompletionItemKind.Class]: mKind.Class,
	[CompletionItemKind.Interface]: mKind.Interface,
	[CompletionItemKind.Module]: mKind.Module,
	[CompletionItemKind.Property]: mKind.Property,
	[CompletionItemKind.Unit]: mKind.Unit,
	[CompletionItemKind.Value]: mKind.Value,
	[CompletionItemKind.Enum]: mKind.Enum,
	[CompletionItemKind.Keyword]: mKind.Keyword,
	[CompletionItemKind.Snippet]: mKind.Snippet,
	[CompletionItemKind.Color]: mKind.Color,
	[CompletionItemKind.File]: mKind.File,
	[CompletionItemKind.Reference]: mKind.Reference,
	[CompletionItemKind.Folder]: mKind.Folder,
	[CompletionItemKind.EnumMember]: mKind.EnumMember,
	[CompletionItemKind.Constant]: mKind.Constant,
	[CompletionItemKind.Struct]: mKind.Struct,
	[CompletionItemKind.Event]: mKind.Event,
	[CompletionItemKind.Operator]: mKind.Operator,
	[CompletionItemKind.TypeParameter]: mKind.TypeParameter
};
function toCompletionItemKind(p) {
	return p in kindMap ? kindMap[p] : mKind.Text;
}
function toCompletion(p) {
	return {
		range: p.range,
		kind: toCompletionItemKind(p.kind),
		label: p.label,
		insertText: p.insertText ?? p.label,
		insertTextRules: p.insertText ? languages.CompletionItemInsertTextRule.InsertAsSnippet : void 0,
		sortText: p.sortText,
		filterText: p.filterText,
		documentation: p.documentation,
		detail: p.detail,
		command: p.command
	};
}
var CompletionAdapter = class {
	_worker;
	constructor(p) {
		this._worker = p, this._worker = p;
	}
	get triggerCharacters() {
		return [
			":",
			"$",
			" ",
			"(",
			"@"
		];
	}
	async provideCompletionItems(p, H, U, W) {
		try {
			return {
				incomplete: !0,
				suggestions: (await (await this._worker(p.uri)).doComplete(p.uri.toString(), H)).map(toCompletion)
			};
		} catch (p) {
			return console.error("Error fetching completion items", p), { suggestions: [] };
		}
	}
}, DocumentFormattingAdapter = class {
	_worker;
	constructor(p) {
		this._worker = p, this._worker = p;
	}
	async provideDocumentFormattingEdits(p, H, U) {
		let W = await (await this._worker(p.uri)).doFormat(p.uri.toString());
		return W ? [{
			range: p.getFullModelRange(),
			text: W
		}] : [];
	}
}, HoverAdapter = class {
	_worker;
	constructor(p) {
		this._worker = p;
	}
	async provideHover(p, H, U) {
		let W = p.uri, G = await (await this._worker(p.uri)).doHover(W.toString(), H);
		return G ? {
			range: G.range,
			contents: [{ value: G.content }]
		} : { contents: [] };
	}
	dispose() {}
};
function setupMode(p) {
	let U = [], W = [], G = new WorkerManager(p);
	U.push(G);
	let K = (...p) => {
		try {
			return G.getLanguageServiceWorker(...p);
		} catch {
			throw Error("Error fetching graphql language service worker");
		}
	};
	function q() {
		let { modeConfiguration: U, languageId: G } = p;
		U.documentFormattingEdits && W.push(languages.registerDocumentFormattingEditProvider(G, new DocumentFormattingAdapter(K)));
	}
	function J(U) {
		let { modeConfiguration: G, languageId: J } = p;
		disposeAll(W), G.completionItems && W.push(languages.registerCompletionItemProvider(J, new CompletionAdapter(K))), G.diagnostics && W.push(new DiagnosticsAdapter(U, K)), G.hovers && W.push(languages.registerHoverProvider(J, new HoverAdapter(K))), q();
	}
	let { modeConfiguration: Y, formattingOptions: X, diagnosticSettings: Z, externalFragmentDefinitions: Q, schemas: $ } = p;
	return J(p), p.onDidChange((p) => {
		p.modeConfiguration !== Y && (Y = p.modeConfiguration, J(p)), p.formattingOptions !== X && (X = p.formattingOptions, q()), p.externalFragmentDefinitions !== Q && (Q = p.externalFragmentDefinitions, J(p)), p.diagnosticSettings !== Z && (Z = p.diagnosticSettings, J(p)), p.schemas !== $ && ($ = p.schemas, J(p));
	}), U.push(asDisposable(W)), asDisposable(U);
}
function asDisposable(p) {
	return { dispose: () => disposeAll(p) };
}
function disposeAll(p) {
	for (; p.length;) p.pop().dispose();
}
export { setupMode };