@graphql-hive/laboratory
Version:
[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.
264 lines (263 loc) • 9.02 kB
JavaScript
import { Yu as __toESM, f as Uri, h as languages, p as editor } from "./editor.api-DPgI1LYm.js";
import { i as CompletionItemKind, o as require_graphql } from "./monaco-editor-OtfP9F5i.js";
import "./monaco.contribution-BUcZa-0g.js";
var import_graphql = /* @__PURE__ */ __toESM(require_graphql());
const getModelLanguageId = (e) => "getModeId" in e ? e.getModeId() : e.getLanguageId(), getStringSchema = (e) => {
let { schema: u, documentAST: d, introspectionJSON: f, introspectionJSONString: p, documentString: m,...g } = e;
if (u) return {
...g,
documentString: (0, import_graphql.printSchema)(u)
};
if (p) return {
...g,
introspectionJSONString: p
};
if (m) return {
...g,
documentString: m
};
if (f) return {
...g,
introspectionJSONString: JSON.stringify(f)
};
if (d) {
let e = (0, import_graphql.buildASTSchema)(d, g.buildSchemaOptions);
return {
...g,
documentString: (0, import_graphql.printSchema)(e)
};
}
throw Error("No schema supplied");
};
var STOP_WHEN_IDLE_FOR = 120 * 1e3, WorkerManager = class {
_defaults;
_idleCheckInterval;
_lastUsedTime = 0;
_configChangeListener;
_worker = null;
_client = null;
constructor(e) {
this._defaults = e, 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: e, formattingOptions: u, schemas: d, externalFragmentDefinitions: p, completionSettings: m } = this._defaults;
this._worker = editor.createWebWorker({
moduleId: "monaco-graphql/esm/GraphQLWorker.js",
label: e,
createData: {
languageId: e,
formattingOptions: u,
languageConfig: {
schemas: d?.map(getStringSchema),
externalFragmentDefinitions: p,
fillLeafsOnComplete: m.__experimental__fillLeafsOnComplete
}
}
}), this._client = this._worker.getProxy();
} catch (e) {
console.error("error loading worker", e);
}
return this._client;
}
async getLanguageServiceWorker(...e) {
let u = await this._getClient();
return await this._worker.withSyncedResources(e), u;
}
}, DiagnosticsAdapter = class {
defaults;
_worker;
_disposables = [];
_listener = Object.create(null);
constructor(e, u) {
this.defaults = e, this._worker = u, this._worker = u;
let d, p = (u) => {
let f = getModelLanguageId(u);
if (f !== this.defaults.languageId) return;
let p = u.uri.toString(), m = e.diagnosticSettings.validateVariablesJSON?.[p];
d = setTimeout(() => {
this._doValidate(u.uri, f, m);
}, 400), this._listener[p] = u.onDidChangeContent(() => {
clearTimeout(d), d = setTimeout(() => {
this._doValidate(u.uri, f, m);
}, 400);
});
}, m = (e) => {
editor.setModelMarkers(e, this.defaults.languageId, []);
let u = e.uri.toString(), d = this._listener[u];
d && (d.dispose(), delete this._listener[u]);
};
this._disposables.push(editor.onDidCreateModel(p), { dispose() {
clearTimeout(d);
} }, editor.onWillDisposeModel((e) => {
m(e);
}), editor.onDidChangeModelLanguage((e) => {
m(e.model), p(e.model);
}), { dispose: () => {
for (let e of Object.values(this._listener)) e.dispose();
} }, e.onDidChange(() => {
for (let e of editor.getModels()) getModelLanguageId(e) === this.defaults.languageId && (m(e), p(e));
}));
for (let e of editor.getModels()) getModelLanguageId(e) === this.defaults.languageId && p(e);
}
dispose() {
for (let e of this._disposables) e.dispose();
this._disposables = [];
}
async _doValidate(e, p, m) {
let h = await this._worker(e);
if (!h) return;
let g = await h.doValidation(e.toString());
if (editor.setModelMarkers(editor.getModel(e), p, g), m) {
if (await import("./monaco.contribution-pnEHc2s_.js"), !m.length) throw Error("No variables URI strings provided to validate");
let f = await h.doGetVariablesJSONSchema(e.toString());
if (!f) return;
let p = Uri.file(m[0].replace(".json", "-schema.json")).toString(), g = {
uri: p,
schema: f,
fileMatch: m
}, _ = languages.json.jsonDefaults.diagnosticsOptions.schemas?.filter((e) => e.uri !== p) || [];
languages.json.jsonDefaults.setDiagnosticsOptions({
schemaValidation: "error",
validate: !0,
...this.defaults.diagnosticSettings.jsonDiagnosticSettings,
schemas: [..._, g],
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(e) {
return e in kindMap ? kindMap[e] : mKind.Text;
}
function toCompletion(e) {
return {
range: e.range,
kind: toCompletionItemKind(e.kind),
label: e.label,
insertText: e.insertText ?? e.label,
insertTextRules: e.insertText ? languages.CompletionItemInsertTextRule.InsertAsSnippet : void 0,
sortText: e.sortText,
filterText: e.filterText,
documentation: e.documentation,
detail: e.detail,
command: e.command
};
}
var CompletionAdapter = class {
_worker;
constructor(e) {
this._worker = e, this._worker = e;
}
get triggerCharacters() {
return [
":",
"$",
" ",
"(",
"@"
];
}
async provideCompletionItems(e, u, d, f) {
try {
return {
incomplete: !0,
suggestions: (await (await this._worker(e.uri)).doComplete(e.uri.toString(), u)).map(toCompletion)
};
} catch (e) {
return console.error("Error fetching completion items", e), { suggestions: [] };
}
}
}, DocumentFormattingAdapter = class {
_worker;
constructor(e) {
this._worker = e, this._worker = e;
}
async provideDocumentFormattingEdits(e, u, d) {
let f = await (await this._worker(e.uri)).doFormat(e.uri.toString());
return f ? [{
range: e.getFullModelRange(),
text: f
}] : [];
}
}, HoverAdapter = class {
_worker;
constructor(e) {
this._worker = e;
}
async provideHover(e, u, d) {
let f = e.uri, p = await (await this._worker(e.uri)).doHover(f.toString(), u);
return p ? {
range: p.range,
contents: [{ value: p.content }]
} : { contents: [] };
}
dispose() {}
};
function setupMode(e) {
let u = [], f = [], p = new WorkerManager(e);
u.push(p);
let m = (...e) => {
try {
return p.getLanguageServiceWorker(...e);
} catch {
throw Error("Error fetching graphql language service worker");
}
};
function h() {
let { modeConfiguration: u, languageId: p } = e;
u.documentFormattingEdits && f.push(languages.registerDocumentFormattingEditProvider(p, new DocumentFormattingAdapter(m)));
}
function g(u) {
let { modeConfiguration: p, languageId: g } = e;
disposeAll(f), p.completionItems && f.push(languages.registerCompletionItemProvider(g, new CompletionAdapter(m))), p.diagnostics && f.push(new DiagnosticsAdapter(u, m)), p.hovers && f.push(languages.registerHoverProvider(g, new HoverAdapter(m))), h();
}
let { modeConfiguration: _, formattingOptions: v, diagnosticSettings: y, externalFragmentDefinitions: b, schemas: x } = e;
return g(e), e.onDidChange((e) => {
e.modeConfiguration !== _ && (_ = e.modeConfiguration, g(e)), e.formattingOptions !== v && (v = e.formattingOptions, h()), e.externalFragmentDefinitions !== b && (b = e.externalFragmentDefinitions, g(e)), e.diagnosticSettings !== y && (y = e.diagnosticSettings, g(e)), e.schemas !== x && (x = e.schemas, g(e));
}), u.push(asDisposable(f)), asDisposable(u);
}
function asDisposable(e) {
return { dispose: () => disposeAll(e) };
}
function disposeAll(e) {
for (; e.length;) e.pop().dispose();
}
export { setupMode };