@neo4j-cypher/react-codemirror 2.0.0-next.4 → 2.0.0-next.5

package/src/lang-cypher/signature-help.ts

@@ -0,0 +1,102 @@
+import { EditorState, StateField } from '@codemirror/state';
+import { showTooltip, Tooltip } from '@codemirror/view';
+import { signatureHelp } from '@neo4j-cypher/language-support';
+import { CypherConfig } from './lang-cypher';
+
+function getTriggerCharacter(query: string, caretPosition: number) {
+  let i = caretPosition - 1;
+  let triggerCharacter = query.at(i);
+
+  // Discard all space characters. Note that a space can be more than just a ' '
+  while (/\s/.test(triggerCharacter) && i > 0) {
+    i -= 1;
+    triggerCharacter = query.at(i);
+  }
+
+  return triggerCharacter;
+}
+
+function getSignatureHelpTooltip(
+  state: EditorState,
+  config: CypherConfig,
+): Tooltip[] {
+  let result: Tooltip[] = [];
+  const schema = config.schema;
+  const ranges = state.selection.ranges;
+  const range = ranges.at(0);
+
+  if (schema && ranges.length === 1 && range.from === range.to) {
+    const caretPosition = range.from;
+    const query = state.doc.toString();
+
+    const triggerCharacter = getTriggerCharacter(query, caretPosition);
+
+    if (triggerCharacter === '(' || triggerCharacter === ',') {
+      const signatureHelpInfo = signatureHelp(query, schema, caretPosition);
+      const activeSignature = signatureHelpInfo.activeSignature;
+      const signatures = signatureHelpInfo.signatures;
+      const activeParameter = signatureHelpInfo.activeParameter;
+
+      if (
+        activeSignature !== undefined &&
+        activeSignature >= 0 &&
+        activeSignature < signatures.length &&
+        signatures[activeSignature].documentation !== undefined
+      ) {
+        const signature = signatures[activeSignature];
+        const parameters = signature.parameters;
+        let doc = signature.documentation.toString();
+
+        if (
+          activeParameter >= 0 &&
+          activeParameter <
+            (signatures[activeSignature].parameters?.length ?? 0)
+        ) {
+          doc =
+            parameters[activeParameter].documentation.toString() + '\n\n' + doc;
+        }
+
+        result = [
+          {
+            pos: caretPosition,
+            above: true,
+            strictSide: true,
+            arrow: true,
+            create: () => {
+              const div = document.createElement('div');
+              const methodName = document.createElement('div');
+              const argPlusDescription = document.createElement('div');
+              const separator = document.createElement('hr');
+              const lineBreak = document.createElement('br');
+
+              div.append(
+                ...[methodName, separator, lineBreak, argPlusDescription],
+              );
+              div.className = 'cm-tooltip-signature-help';
+
+              methodName.innerText = signature.label;
+              argPlusDescription.innerText = doc;
+
+              return { dom: div };
+            },
+          },
+        ];
+      }
+    }
+  }
+
+  return result;
+}
+
+export function signatureHelpTooltip(config: CypherConfig) {
+  return StateField.define<readonly Tooltip[]>({
+    create: (state) => getSignatureHelpTooltip(state, config),
+
+    update(tooltips, tr) {
+      if (!tr.docChanged && !tr.selection) return tooltips;
+      return getSignatureHelpTooltip(tr.state, config);
+    },
+
+    provide: (f) => showTooltip.computeN([f], (state) => state.field(f)),
+  });
+}

package/src/lang-cypher/syntax-validation.ts

@@ -1,8 +1,22 @@
-import { linter } from '@codemirror/lint';
+import { Diagnostic, linter } from '@codemirror/lint';
 import { Extension } from '@codemirror/state';
-import { validateSyntax } from '@neo4j-cypher/language-support';
+import { parserWrapper, validateSyntax } from '@neo4j-cypher/language-support';
 import { DiagnosticSeverity } from 'vscode-languageserver-types';
+import workerpool from 'workerpool';
 import type { CypherConfig } from './lang-cypher';
+import type { LinterTask, LintWorker } from './lint-worker';
+
+// eslint-disable-next-line @typescript-eslint/ban-ts-comment
+// @ts-ignore ignore: https://v3.vitejs.dev/guide/features.html#import-with-query-suffixes
+import WorkerURL from './lint-worker?url&worker';
+
+const pool = workerpool.pool(WorkerURL as string, {
+  minWorkers: 2,
+  workerOpts: { type: 'module' },
+  workerTerminateTimeout: 2000,
+});
+
+let lastSemanticJob: LinterTask | undefined;
 
 export const cypherLinter: (config: CypherConfig) => Extension = (config) =>
   linter((view) => {
@@ -10,8 +24,11 @@ export const cypherLinter: (config: CypherConfig) => Extension = (config) =>
       return [];
     }
 
-    return validateSyntax(view.state.doc.toString(), config.schema).map(
-      (diagnostic) => ({
+    const query = view.state.doc.toString();
+    const syntaxErrors = validateSyntax(query, config.schema ?? {});
+
+    return syntaxErrors.map(
+      (diagnostic): Diagnostic => ({
         from: diagnostic.offsets.start,
         to: diagnostic.offsets.end,
         severity:
@@ -22,3 +39,52 @@ export const cypherLinter: (config: CypherConfig) => Extension = (config) =>
       }),
     );
   });
+
+export const semanticAnalysisLinter: (config: CypherConfig) => Extension = (
+  config,
+) =>
+  linter(async (view) => {
+    if (!config.lint) {
+      return [];
+    }
+
+    const query = view.state.doc.toString();
+    if (query.length === 0) {
+      return [];
+    }
+
+    // we want to avoid the ANTLR4 reparse in the worker thread, this should hit our main thread cache
+    const parse = parserWrapper.parse(query);
+    if (parse.diagnostics.length !== 0) {
+      return [];
+    }
+
+    try {
+      if (lastSemanticJob !== undefined && !lastSemanticJob.resolved) {
+        void lastSemanticJob.cancel();
+      }
+
+      const proxyWorker = (await pool.proxy()) as unknown as LintWorker;
+      lastSemanticJob = proxyWorker.validateSemantics(query);
+      const result = await lastSemanticJob;
+
+      return result.map((diag) => {
+        return {
+          from: diag.offsets.start,
+          to: diag.offsets.end,
+          severity:
+            diag.severity === DiagnosticSeverity.Error ? 'error' : 'warning',
+          message: diag.message,
+        };
+      });
+    } catch (err) {
+      if (!(err instanceof workerpool.Promise.CancellationError)) {
+        console.error(String(err) + ' ' + query);
+      }
+    }
+    return [];
+  });
+
+export const cleanupWorkers = () => {
+  void pool.terminate();
+};

package/src/themes.ts

@@ -60,6 +60,7 @@ export const lightThemeConstants: ThemeOptions = {
     paramDollar: light.syntax.regexp.hex(),
     paramValue: light.syntax.regexp.hex(),
     namespace: light.syntax.special.hex(),
+    consoleCommand: light.editor.fg.hex(),
   },
 };
 
@@ -101,6 +102,7 @@ export const darkThemeConstants: ThemeOptions = {
     paramDollar: mirage.syntax.regexp.hex(),
     paramValue: mirage.syntax.regexp.hex(),
     namespace: mirage.syntax.special.hex(),
+    consoleCommand: mirage.editor.fg.hex(),
   },
 };