@qoretechnologies/reqraft 0.10.66-pr.145.gcb1e59d → 0.10.66

package/src/components/dpqlEditor/DpqlEditor.tsx

@@ -1,219 +0,0 @@
-// Copyright 2026 Qore Technologies, s.r.o.
-// DpqlEditor — Slate-based DPQL smart text field. Thin wrapper over the
-// generic `SmartEditor` primitive, configured with DPQL-flavored knobs:
-// regex-driven syntax highlighting, tag rendering for $template / @field,
-// plain-text↔Slate conversion that recognises DPQL tag patterns, and
-// tag-element insertion for completions whose `insertText` starts with
-// `@` or `$`.
-//
-// Templates and fields are BOTH served by the LSP server through the
-// completion stream: typing `$` opens templates, `@` opens field
-// references (the server's `dpql-get-completions` is position-aware).
-// There is intentionally no client-side "Templates" button — it would
-// duplicate what the server already returns on `$`.
-
-import {
-  forwardRef,
-  useEffect,
-  useImperativeHandle,
-  useMemo,
-  useRef,
-  useState,
-} from 'react';
-import { SmartEditor } from '../smartEditor/SmartEditor';
-import { ISlateConverter, ISlateElement } from '../smartEditor/types';
-import { dpqlSlateConverter, richtextResponseToSlate } from './dpqlHelpers';
-import { dpqlCompletionInserter } from './dpqlInserter';
-import { makeDpqlTagRenderer } from './dpqlTags';
-import { IDpqlEditorProps, IDpqlEditorRef } from './types';
-import { useDpqlSession } from './useDpqlSession';
-
-export type { IDpqlEditorProps, IDpqlEditorRef };
-
-// Trigger characters that open the autocomplete on typing. Space is
-// deliberately NOT in the set — typing a space after a chip (or after a
-// keyword like `==`) shouldn't pop the dropdown. Sigils (`@`, `$`) and
-// in-token punctuation (`.`, `:`) cover the meaningful cases; the rest
-// of completion is handled by typing inside an already-open token.
-const DPQL_TRIGGERS = new Set(['@', '$', '.', ':']);
-
-export const DpqlEditor = forwardRef<IDpqlEditorRef, IDpqlEditorProps>(
-  (
-    {
-      value,
-      onChange,
-      provider,
-      recordType,
-      options,
-      actionCode,
-      height,
-      readOnly = false,
-      showDiagnostics = true,
-      enableHover = true,
-      templateTagsUseIntent = false,
-      loadingIndicator,
-      templates,
-      onBlur,
-      useServerParse = false,
-      fields,
-      alertPayloadContext = false,
-      fsmContext,
-    },
-    ref
-  ) => {
-    const dpql = useDpqlSession({
-      provider,
-      recordType,
-      options,
-      fields,
-      actionCode,
-      initialText: value,
-      alertPayloadContext,
-      fsmContext,
-    });
-
-    // Server-parse state: when `useServerParse` is true, we ask the
-    // LSP server's `dpql/toRichtext` to convert the plain-text value
-    // into a structured Slate tree. The result is cached against the
-    // `value` it parsed — so subsequent renders with the same text
-    // reuse it without another roundtrip. `null` until the first
-    // response arrives (or when the request errored — caller falls
-    // back to the client-side regex parser via `dpqlSlateConverter`).
-    const [serverParsedNodes, setServerParsedNodes] = useState<
-      ISlateElement[] | null
-    >(null);
-    const [serverParsedFor, setServerParsedFor] = useState<string | null>(
-      null
-    );
-    const [isParsing, setIsParsing] = useState(false);
-    // Tracks the most recent in-flight request so a slow response
-    // can't overwrite a newer one (the user typed faster than the
-    // server replied).
-    const parseRequestIdRef = useRef(0);
-
-    useEffect(() => {
-      if (!useServerParse) {
-        // Clear any cached server-parsed nodes when the prop is
-        // toggled off — next render uses the client-side converter.
-        setServerParsedNodes(null);
-        setServerParsedFor(null);
-        setIsParsing(false);
-        return;
-      }
-      const client = dpql.session.client;
-      if (!client || !dpql.session.isReady) return;
-      // Empty value — short-circuit to the empty document so the user
-      // doesn't see a spinner for a no-op parse.
-      if (!value) {
-        setServerParsedNodes([{ type: 'paragraph', children: [{ text: '' }] }]);
-        setServerParsedFor('');
-        setIsParsing(false);
-        return;
-      }
-      // Already parsed this exact text — no need to re-request.
-      if (serverParsedFor === value && serverParsedNodes) {
-        return;
-      }
-      const reqId = ++parseRequestIdRef.current;
-      setIsParsing(true);
-      client
-        .customRequest<unknown>('dpql/toRichtext', { text: value })
-        .then((response) => {
-          if (reqId !== parseRequestIdRef.current) return;
-          const nodes = richtextResponseToSlate(response);
-          if (nodes) {
-            setServerParsedNodes(nodes);
-            setServerParsedFor(value);
-          } else {
-            // Bad shape — fall back to client-side parsing by leaving
-            // the cache empty for this value. The custom converter
-            // below detects the miss and uses `plainTextToSlate`.
-            setServerParsedNodes(null);
-            setServerParsedFor(null);
-          }
-        })
-        .catch(() => {
-          // Network / server error — same fallback as bad-shape.
-          if (reqId !== parseRequestIdRef.current) return;
-          setServerParsedNodes(null);
-          setServerParsedFor(null);
-        })
-        .finally(() => {
-          if (reqId === parseRequestIdRef.current) {
-            setIsParsing(false);
-          }
-        });
-    }, [
-      useServerParse,
-      value,
-      dpql.session.client,
-      dpql.session.isReady,
-      serverParsedFor,
-      serverParsedNodes,
-    ]);
-
-    // When server-parse is active, override `toSlateNodes` so SmartEditor
-    // gets the server's tree for the matching value, falling through to
-    // the client regex parser for anything else (initial empty string,
-    // mid-edit echoes, error fallbacks). Other converter methods are
-    // delegated to the base — slate→plain text and offset math are pure
-    // and don't need server input.
-    const converter = useMemo<ISlateConverter>(() => {
-      if (!useServerParse) return dpqlSlateConverter;
-      return {
-        ...dpqlSlateConverter,
-        toSlateNodes: (text: string) => {
-          if (
-            text === serverParsedFor &&
-            serverParsedNodes
-          ) {
-            return serverParsedNodes;
-          }
-          return dpqlSlateConverter.toSlateNodes(text);
-        },
-      };
-    }, [useServerParse, serverParsedFor, serverParsedNodes]);
-
-    const tagRenderer = useMemo(
-      () => makeDpqlTagRenderer(dpql.fieldMeta, { templateTagsUseIntent, templates }),
-      [dpql.fieldMeta, templateTagsUseIntent, templates]
-    );
-
-    useImperativeHandle(
-      ref,
-      (): IDpqlEditorRef => ({
-        format: async () => {
-          const formatted = await dpql.session.format();
-          if (formatted !== null && formatted !== value) {
-            onChange(formatted);
-          }
-        },
-        validate: dpql.validate,
-        parse: dpql.parse,
-        serialize: dpql.serialize,
-      }),
-      [dpql, value, onChange]
-    );
-
-    return (
-      <SmartEditor
-        session={dpql.session}
-        value={value}
-        onChange={onChange}
-        tagRenderer={tagRenderer}
-        triggerCharacters={DPQL_TRIGGERS}
-        converter={converter}
-        completionInserter={dpqlCompletionInserter}
-        height={height}
-        readOnly={readOnly}
-        showDiagnostics={showDiagnostics}
-        enableHover={enableHover}
-        onBlur={onBlur}
-        isLoading={isParsing}
-        loadingIndicator={loadingIndicator}
-      />
-    );
-  }
-);
-
-DpqlEditor.displayName = 'DpqlEditor';

package/src/components/dpqlEditor/dpqlHelpers.ts

@@ -1,287 +0,0 @@
-// Copyright 2026 Qore Technologies, s.r.o.
-// DPQL-specific Slate helpers — recognise `@field` and `$prefix:value`
-// patterns in plain text, render them as tag elements, account for
-// `metadata.quoted` tag spacing in cursor-offset math. The generic
-// SmartEditor primitive uses these via the `converter` prop on
-// `DpqlEditor`; the SmartEditor itself has no knowledge of DPQL syntax.
-
-import { ISlateConverter, ISlateElement, ISlateText, TSlateNode } from '../smartEditor/types';
-
-// Combined pattern that matches templates, field refs, or plain text segments.
-// Template values without braces match only word chars and dots (not quotes,
-// parens, etc.); the `(?<![.\w])` lookbehind on `@` prevents matching inside
-// an email-like string.
-//
-// A dot that starts a method call ends the value: the server's readable
-// rendering writes `ends-with` as `$local:str.endsWith($local:p, true)`, and a
-// path that took every dot turned `str.endsWith` into one reference.
-//
-// A field name is bare in any script, as DPQL reads it (qorus#646): a letter of any script or `_`, then
-// letters, combining marks, digits and `_`, with dot-separated parts. `\w` is ASCII only, so
-// `@menge_bestätigt` was cut to the tag `@menge_best` and the text `ätigt`.
-const NAME_START = '[\\p{L}_]';
-const NAME_PART = '[\\p{L}\\p{M}\\p{N}_]';
-const FIELD_NAME = `${NAME_START}${NAME_PART}*`;
-const TOKEN_PATTERN = new RegExp(
-  `(\\$\\w+:(?:\\{[^}]*\\}|(?:\\w|\\.(?!\\w+\\())+))|((?<![.\\p{L}\\p{M}\\p{N}_])@${FIELD_NAME}(?:\\.${FIELD_NAME})*)`,
-  'gu'
-);
-
-/**
- * Convert plain DPQL text to Slate elements. Parses `$prefix:{value}` and
- * `@field` patterns into tag elements; everything else becomes text nodes.
- */
-export function plainTextToSlate(text: string): ISlateElement[] {
-  if (!text) {
-    return [{ type: 'paragraph', children: [{ text: '' }] }];
-  }
-  const lines = text.split('\n');
-
-  return lines.map((line) => {
-    const children: TSlateNode[] = [];
-    if (!line) {
-      children.push({ text: '' });
-      return { type: 'paragraph' as const, children };
-    }
-    let lastIndex = 0;
-    TOKEN_PATTERN.lastIndex = 0;
-    let match: RegExpExecArray | null;
-    while ((match = TOKEN_PATTERN.exec(line)) !== null) {
-      const matchStart = match.index;
-      const matchEnd = matchStart + match[0].length;
-      const isQuoted =
-        matchStart > 0 &&
-        line[matchStart - 1] === '"' &&
-        matchEnd < line.length &&
-        line[matchEnd] === '"';
-      const textStart = isQuoted ? matchStart - 1 : matchStart;
-      const textEnd = isQuoted ? matchEnd + 1 : matchEnd;
-
-      if (textStart > lastIndex) {
-        children.push({ text: line.slice(lastIndex, textStart) });
-      }
-
-      const fullMatch = match[0];
-      if (match[1]) {
-        const colonIdx = fullMatch.indexOf(':');
-        const prefix = fullMatch.slice(1, colonIdx);
-        const valueText = fullMatch.slice(colonIdx + 1);
-        const displayLabel =
-          valueText.startsWith('{') && valueText.endsWith('}')
-            ? valueText.slice(1, -1)
-            : valueText;
-        children.push(
-          createTagElement(
-            fullMatch,
-            `${prefix}: ${displayLabel}`,
-            isQuoted ? { quoted: true } : undefined
-          )
-        );
-      } else if (match[2]) {
-        const fieldName = fullMatch.slice(1);
-        children.push(createTagElement(fullMatch, fieldName));
-      }
-
-      lastIndex = textEnd;
-    }
-    if (lastIndex < line.length) {
-      children.push({ text: line.slice(lastIndex) });
-    }
-    if (children.length === 0) {
-      children.push({ text: '' });
-    }
-    return { type: 'paragraph' as const, children };
-  });
-}
-
-/**
- * `text` as a DPQL editor draws it: a reference is its chip, so the quotes a
- * chip is drawn over do not show. `"$local:name" == "John"` and
- * `$local:name == "John"` read the same.
- */
-export function dpqlDisplayedText(text: string): string {
-  return plainTextToSlate(text)
-    .map((paragraph) =>
-      paragraph.children
-        .map((node) => ('text' in node ? node.text : String((node as ISlateElement).value ?? '')))
-        .join('')
-    )
-    .join('\n');
-}
-
-function createTagElement(
-  value: string,
-  label: string,
-  metadata?: Record<string, any>
-): ISlateElement {
-  return {
-    type: 'tag',
-    value,
-    label,
-    metadata,
-    children: [{ text: '' }],
-  };
-}
-
-/** Convert Slate elements back to plain DPQL text. */
-export function slateToPlainText(elements: ISlateElement[]): string {
-  return elements.map(processElement).join('\n');
-}
-
-function processElement(element: TSlateNode): string {
-  if ('text' in element) {
-    return element.text;
-  }
-  if (element.type === 'tag') {
-    const val = element.value?.toString() || '';
-    return element.metadata?.quoted ? `"${val}"` : val;
-  }
-  if (element.children) {
-    return element.children.map(processElement).join('');
-  }
-  return '';
-}
-
-/**
- * Tag-aware Slate-selection → plain-text-offset. Accounts for
- * `metadata.quoted` (which adds two characters — surrounding quotes — to
- * the plain-text projection of a tag). The non-quoted case matches the
- * generic SmartEditor default.
- */
-export function slateSelectionToOffset(
-  elements: ISlateElement[],
-  anchorPath: number[],
-  anchorOffset: number
-): number {
-  let totalOffset = 0;
-  const targetParagraphIdx = anchorPath[0];
-  const targetChildIdx = anchorPath[1];
-
-  for (let pIdx = 0; pIdx < elements.length; pIdx++) {
-    if (pIdx > 0) {
-      totalOffset += 1;
-    }
-    if (pIdx > targetParagraphIdx) break;
-
-    const paragraph = elements[pIdx];
-    const children = paragraph.children || [];
-
-    for (let cIdx = 0; cIdx < children.length; cIdx++) {
-      const child = children[cIdx];
-      const isTag = 'type' in child && child.type === 'tag';
-      const isText = 'text' in child && !isTag;
-
-      if (pIdx === targetParagraphIdx && cIdx === targetChildIdx) {
-        if (isText) {
-          totalOffset += anchorOffset;
-        } else if (isTag) {
-          const el = child as ISlateElement;
-          const quoted = el.metadata?.quoted;
-          totalOffset += quoted ? 1 + anchorOffset : anchorOffset;
-        }
-        return totalOffset;
-      }
-
-      if (isText) {
-        totalOffset += (child as ISlateText).text.length;
-      } else if (isTag) {
-        const el = child as ISlateElement;
-        const tagValue = el.value?.toString() || '';
-        const quoted = el.metadata?.quoted;
-        totalOffset += quoted ? tagValue.length + 2 : tagValue.length;
-      }
-    }
-  }
-  return totalOffset;
-}
-
-/** Should a completion be inserted as a Slate tag element vs plain text? */
-export function isTagCompletion(insertText: string): boolean {
-  return insertText.startsWith('@') || insertText.startsWith('$');
-}
-
-/** Display label for a completion being inserted as a tag. */
-export function getTagLabel(value: string): string {
-  if (value.startsWith('@')) {
-    return value.slice(1);
-  }
-  if (value.startsWith('$')) {
-    const colonIdx = value.indexOf(':');
-    if (colonIdx === -1) {
-      return value.slice(1);
-    }
-    const prefix = value.slice(1, colonIdx);
-    const rest = value.slice(colonIdx + 1);
-    const displayValue =
-      rest.startsWith('{') && rest.endsWith('}') ? rest.slice(1, -1) : rest;
-    return `${prefix}: ${displayValue}`;
-  }
-  return value;
-}
-
-/** DPQL converter — handed to `SmartEditor` via the `converter` prop. */
-export const dpqlSlateConverter: ISlateConverter = {
-  toSlateNodes: plainTextToSlate,
-  fromSlateNodes: slateToPlainText,
-  selectionToOffset: slateSelectionToOffset,
-};
-
-/**
- * Convert the server's `dpql/toRichtext` response into a Slate
- * `ISlateElement[]`. The server returns `{ type: "richtext", value:
- * [...] }` where `value` is already an array of `{type: "paragraph",
- * children: [...]}` nodes — children alternate between
- * `{ text: "..." }` text nodes and `{ type: "tag", value, label,
- * children: [{text: ""}], metadata? }` inline-void tag nodes (see
- * `qorus/Classes/UserApi.qc:_priv_get_richtext_string`).
- *
- * Returns `null` when the response doesn't look like the expected
- * shape — callers should fall back to `plainTextToSlate` in that
- * case. We don't trust the server response unconditionally because
- * (a) the regex used server-side recognises `$template:value`
- * patterns but NOT `@field` references, so DPQL field-ref chips are
- * only produced by the client parser, and (b) network errors / weird
- * shapes shouldn't crash the editor.
- */
-export function richtextResponseToSlate(
-  response: unknown
-): ISlateElement[] | null {
-  if (!response || typeof response !== 'object') return null;
-  const r = response as { type?: unknown; value?: unknown };
-  if (r.type !== 'richtext' || !Array.isArray(r.value)) return null;
-  const paragraphs: ISlateElement[] = [];
-  for (const node of r.value) {
-    if (!node || typeof node !== 'object') return null;
-    const n = node as { type?: unknown; children?: unknown };
-    if (n.type !== 'paragraph' || !Array.isArray(n.children)) return null;
-    const children: TSlateNode[] = [];
-    for (const child of n.children) {
-      if (!child || typeof child !== 'object') return null;
-      const c = child as Record<string, unknown>;
-      if (typeof c.text === 'string') {
-        children.push({ text: c.text } as ISlateText);
-      } else if (c.type === 'tag' && typeof c.value === 'string') {
-        children.push({
-          type: 'tag',
-          value: c.value,
-          label:
-            typeof c.label === 'string'
-              ? c.label
-              : getTagLabel(c.value),
-          metadata: (c.metadata as Record<string, any>) ?? undefined,
-          children: [{ text: '' } as ISlateText],
-        } as ISlateElement);
-      } else {
-        // Unknown child shape — refuse the whole response so the
-        // caller falls back to client-side parsing.
-        return null;
-      }
-    }
-    if (children.length === 0) children.push({ text: '' } as ISlateText);
-    paragraphs.push({ type: 'paragraph', children });
-  }
-  if (paragraphs.length === 0) {
-    paragraphs.push({ type: 'paragraph', children: [{ text: '' }] });
-  }
-  return paragraphs;
-}

package/src/components/dpqlEditor/dpqlInserter.ts

@@ -1,121 +0,0 @@
-// Copyright 2026 Qore Technologies, s.r.o.
-// DPQL-specific completion inserter — inserts `@field` and `$template`
-// completions as Slate tag elements (so they render as interactive chips
-// in the editor) and falls back to plain text for keywords/operators.
-
-import { BaseEditor, Editor, Transforms } from 'slate';
-import { HistoryEditor } from 'slate-history';
-import { ReactEditor } from 'slate-react';
-import { expandSnippet, lspPositionToOffset } from '../smartEditor/helpers';
-import { ISlateElement, TCompletionInserter } from '../smartEditor/types';
-import { getTagLabel, isTagCompletion } from './dpqlHelpers';
-
-/**
- * Walk back from the cursor to find the start of the partial token the
- * user typed. Matches the same heuristic the generic
- * `useLspAutocomplete.findTokenStart` uses internally — duplicated here
- * because the inserter runs at completion-accept time and needs to slice
- * the partial token before inserting the chosen completion.
- */
-function findTokenStart(plainText: string, cursorOffset: number): number {
-  let i = cursorOffset - 1;
-  while (i >= 0 && /[\w.:{}-]/.test(plainText[i])) {
-    i--;
-  }
-  if (i >= 0 && /[@$]/.test(plainText[i])) {
-    i--;
-  }
-  return i + 1;
-}
-
-/**
- * DPQL completion inserter. For tag completions (`@field` / `$template:…`),
- * inserts a Slate tag element so the value renders as an interactive chip.
- * For everything else (keywords, operators, functions), inserts plain text.
- *
- * Partial-token deletion happens first. When the server supplies a
- * `textEdit.range`, that's the authoritative span to replace; we delete
- * from `textEdit.range.start` to the current cursor (matching the LSP
- * spec). Without `textEdit`, fall back to the find-token-start heuristic.
- */
-export const dpqlCompletionInserter: TCompletionInserter = (item, editor, ctx) => {
-  const ed = editor as BaseEditor & ReactEditor & HistoryEditor;
-  const rawValue = item.textEdit?.newText ?? item.insertText ?? item.label;
-  // Expand LSP snippets (`insertTextFormat === 2`) so function templates
-  // like `slice(${1:List Value}, ${2:Index or Range})$0` insert as
-  // `slice(List Value, Index or Range)` instead of leaking the snippet
-  // syntax. Tag completions (`@field` / `$template`) are never snippets.
-  const insertValue =
-    item.insertTextFormat === 2 ? expandSnippet(rawValue) : rawValue;
-
-  // Replace mode — user clicked an existing chip. Atomically swap the
-  // node at the chip's path for the chosen completion. No token-delete
-  // dance, no selection dependency — just `removeNodes` + `insertNodes`
-  // inside `withoutNormalizing` so Slate sees a single batched op.
-  if (ctx.replacementPath) {
-    const path = ctx.replacementPath;
-    Editor.withoutNormalizing(ed, () => {
-      Transforms.removeNodes(ed, { at: path });
-      if (isTagCompletion(insertValue)) {
-        const tagElement: ISlateElement = {
-          type: 'tag',
-          value: insertValue,
-          label: getTagLabel(insertValue),
-          children: [{ text: '' }],
-        };
-        Transforms.insertNodes(ed, tagElement as any, { at: path, select: true });
-      } else {
-        Transforms.insertNodes(ed, [{ text: insertValue }] as any, {
-          at: path,
-          select: true,
-        });
-      }
-    });
-    try {
-      ReactEditor.focus(ed);
-    } catch {
-      // Editor may not be focusable in this render cycle.
-    }
-    return;
-  }
-
-  // Normal (typing) path — needs a live selection. Compute how many
-  // plain-text characters of the partial token to delete before
-  // inserting at the cursor.
-  if (!ed.selection) return;
-
-  let charsToDelete: number;
-  if (item.textEdit) {
-    const startOffset = lspPositionToOffset(ctx.plainText, item.textEdit.range.start);
-    charsToDelete = Math.max(0, ctx.cursorOffset - startOffset);
-  } else {
-    // Heuristic fallback — same logic the old DPQL inserter used.
-    const tokenStart = findTokenStart(ctx.plainText, ctx.cursorOffset);
-    charsToDelete = Math.max(0, ctx.cursorOffset - tokenStart);
-  }
-
-  if (charsToDelete > 0) {
-    for (let i = 0; i < charsToDelete; i++) {
-      Editor.deleteBackward(ed, { unit: 'character' });
-    }
-  }
-
-  if (isTagCompletion(insertValue)) {
-    const tagElement: ISlateElement = {
-      type: 'tag',
-      value: insertValue,
-      label: getTagLabel(insertValue),
-      children: [{ text: '' }],
-    };
-    Transforms.insertNodes(ed, tagElement as any);
-    Transforms.move(ed);
-  } else {
-    Transforms.insertText(ed, insertValue);
-  }
-
-  try {
-    ReactEditor.focus(ed);
-  } catch {
-    // Editor may not be focused.
-  }
-};