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

package/src/components/smartEditor/useLspSession.ts

@@ -1,231 +0,0 @@
-// Copyright 2026 Qore Technologies, s.r.o.
-// Generic LSP session lifecycle hook. Manages a single `ReqraftLspClient` instance
-// per-mount: connect → didOpen with optional metadata → forward subsequent
-// content changes via didChange → expose the live client so wrappers can
-// dispatch language-specific custom methods (e.g. `dpql/setContext`,
-// `qonsole/assist`). Cleans up on unmount.
-
-import { useCallback, useEffect, useRef, useState } from 'react';
-import { ReqraftLspClient } from '../../utils/lspClient';
-import {
-  ILspCompletionItem,
-  ILspDiagnostic,
-  ILspSemanticTokensLegend,
-  ILspServerCapabilities,
-} from '../../utils/lspClient.types';
-import { offsetToLspPosition } from './helpers';
-
-let lspUriCounter = 0;
-
-export interface IUseLspSessionOptions {
-  languageId: string;
-  /**
-   * Document URI. If omitted, a random URI is generated using `languageId`
-   * as the scheme: `<languageId>://session/<counter>`. Caller-provided URIs
-   * must be opaque (no secrets / session tokens / sandbox IDs).
-   */
-  uri?: string;
-  /** Optional metadata sent as `textDocument.metadata` on `didOpen`. */
-  initialMetadata?: Record<string, any>;
-  /** WebSocket path. Default: `'lsp'`. */
-  url?: string;
-  /** Initial document text sent on `didOpen`. Default: empty string. */
-  initialText?: string;
-}
-
-export interface IUseLspSessionResult {
-  /** The live `ReqraftLspClient`, or `null` before connect resolves / after disconnect. */
-  client: ReqraftLspClient | null;
-  /** The URI bound to this session. */
-  uri: string;
-  /** Becomes `true` once `initialize` + `didOpen` complete. */
-  isReady: boolean;
-  /**
-   * Becomes `true` once any language-specific context binding the
-   * wrapper requires has resolved. For the generic primitive session
-   * this is always `true` (no context). Wrappers like `useDpqlSession`
-   * override it: it's `false` while a `dpql/setContext` /
-   * `dpql/setFsmContext` / `dpql/setAlertPayloadContext` request is
-   * in flight after `isReady` flipped, and flips `true` once the
-   * binding resolves (success or error — see the wrapper for
-   * details).
-   *
-   * SmartEditor and its child hooks gate LSP requests on the
-   * combined signal `isReady && isContextReady`: without it, a fast
-   * user typing `@` in the ~50–200ms window between LSP-ready and
-   * context-bound would hit the server context-less and get empty
-   * results, with the dropdown auto-closing silently.
-   */
-  isContextReady: boolean;
-  /** Most-recent `textDocument/publishDiagnostics` payload for this document. */
-  diagnostics: ILspDiagnostic[];
-  /**
-   * The server's semantic-tokens legend, captured from
-   * `initialize → capabilities.semanticTokensProvider.legend`. `null`
-   * before the initialize response arrives or when the server doesn't
-   * advertise semantic tokens. Consumers (`useLspSemanticTokens`) need
-   * it to resolve int-encoded `tokenType` / `tokenModifiers` indices.
-   *
-   * Kept for backwards compatibility — new code should prefer
-   * `capabilities?.semanticTokensProvider?.legend`.
-   */
-  semanticTokensLegend: ILspSemanticTokensLegend | null;
-  /**
-   * Full `capabilities` block from the server's initialize response.
-   * `null` until the handshake completes. Hooks gate features on the
-   * presence of the relevant provider (e.g. `useLspSignatureHelp`
-   * only fires when `capabilities?.signatureHelpProvider` exists).
-   */
-  capabilities: ILspServerCapabilities | null;
-  /**
-   * The editor now holds `text`: the server is sent it via `didChange`, or via
-   * `didOpen` if the document is not open yet. Text the server already holds
-   * is not resent, so it is safe to call for every value the editor shows.
-   */
-  didChange: (text: string) => void;
-  /**
-   * Request `textDocument/completion` at a plain-text offset. Converts
-   * offset → LSP line/character at the boundary; returns the standard
-   * `ILspCompletionItem[]`.
-   */
-  getCompletions: (plainText: string, offset: number) => Promise<ILspCompletionItem[]>;
-  /** Request `textDocument/formatting`. Returns the new full document text, or null. */
-  format: () => Promise<string | null>;
-}
-
-export function useLspSession(
-  options: IUseLspSessionOptions
-): IUseLspSessionResult {
-  const { languageId, uri: uriProp, initialMetadata, url, initialText = '' } = options;
-
-  const clientRef = useRef<ReqraftLspClient | null>(null);
-  const versionRef = useRef(1);
-  /* The text the editor holds, and the text the server holds for this
-     document — `null` until the document is open. The server tokenises and
-     diagnoses ITS copy, so every text the editor shows has to reach it, however
-     it got there: typed, or set from outside after mount (a Text view seeded
-     once `dpql/serialize` answers, a Preview following the typing). */
-  const editorTextRef = useRef(initialText);
-  const serverTextRef = useRef<string | null>(null);
-  const uriRef = useRef(uriProp ?? `${languageId}://session/${++lspUriCounter}`);
-
-  const [client, setClient] = useState<ReqraftLspClient | null>(null);
-  const [isReady, setIsReady] = useState(false);
-  const [diagnostics, setDiagnostics] = useState<ILspDiagnostic[]>([]);
-  const [semanticTokensLegend, setSemanticTokensLegend] =
-    useState<ILspSemanticTokensLegend | null>(null);
-  const [capabilities, setCapabilities] =
-    useState<ILspServerCapabilities | null>(null);
-
-  useEffect(() => {
-    const c = new ReqraftLspClient({
-      languageId,
-      uri: uriRef.current,
-      url,
-    });
-    clientRef.current = c;
-    setClient(c);
-
-    c.onDiagnostics((_uri, diags) => {
-      setDiagnostics(diags);
-    });
-
-    c.onReady(setIsReady);
-
-    // the session ends when the editor goes: a connection it closes itself has not failed
-    let disposed = false;
-    c.connect()
-      .then(() => {
-        // Initialize completed — mirror the captured server
-        // capabilities (including the semantic-tokens legend) into
-        // React state so consumers can subscribe via the session
-        // result.
-        setSemanticTokensLegend(c.semanticTokensLegend);
-        setCapabilities(c.capabilities);
-        // Opened with the text the editor holds NOW, which may have been set
-        // while the connection was opening.
-        serverTextRef.current = editorTextRef.current;
-        c.didOpen(
-          editorTextRef.current,
-          initialMetadata && Object.keys(initialMetadata).length > 0
-            ? initialMetadata
-            : undefined
-        );
-        setIsReady(true);
-      })
-      .catch((err) => {
-        if (disposed) {
-          // the editor went before the connection opened (Text mode left again, a form closed): it was
-          // closed on purpose, which is not a failure to report
-          return;
-        }
-        // eslint-disable-next-line no-console
-        console.error('[LSP session] Connect failed:', err);
-        setIsReady(false);
-      });
-
-    return () => {
-      disposed = true;
-      c.disconnect();
-      clientRef.current = null;
-      serverTextRef.current = null;
-      setClient(null);
-      setIsReady(false);
-      setSemanticTokensLegend(null);
-      setCapabilities(null);
-    };
-    // Connect once per mount. Metadata changes after mount are the
-    // wrapper's responsibility (via the exposed `client` ref and the
-    // appropriate custom method).
-    // eslint-disable-next-line
-  }, []);
-
-  const didChange = useCallback((text: string) => {
-    editorTextRef.current = text;
-    const c = clientRef.current;
-    // Not open yet: `didOpen` will carry it. Already held: nothing to send.
-    if (!c || serverTextRef.current === null || serverTextRef.current === text) return;
-    serverTextRef.current = text;
-    c.didChange(text, ++versionRef.current);
-  }, []);
-
-  const getCompletions = useCallback(
-    async (plainText: string, offset: number): Promise<ILspCompletionItem[]> => {
-      const c = clientRef.current;
-      if (!c) return [];
-      const { line, character } = offsetToLspPosition(plainText, offset);
-      try {
-        return await c.getCompletions(line, character);
-      } catch {
-        return [];
-      }
-    },
-    []
-  );
-
-  const format = useCallback(async (): Promise<string | null> => {
-    const c = clientRef.current;
-    if (!c) return null;
-    try {
-      return await c.format();
-    } catch {
-      return null;
-    }
-  }, []);
-
-  return {
-    client,
-    uri: uriRef.current,
-    isReady,
-    // Generic session has no language-specific context to bind;
-    // wrappers (`useDpqlSession`) override this on their returned
-    // session by spreading + replacing.
-    isContextReady: true,
-    diagnostics,
-    semanticTokensLegend,
-    capabilities,
-    didChange,
-    getCompletions,
-    format,
-  };
-}

package/src/components/smartEditor/useLspSignatureHelp.ts

@@ -1,198 +0,0 @@
-// Copyright 2026 Qore Technologies, s.r.o.
-// Signature-help support for SmartEditor — pinned popover that shows
-// the active call's signature label, the active parameter highlighted,
-// and the active parameter's documentation. Fires on document/selection
-// changes (debounced); the server's signatureHelp handler decides what
-// (if anything) to return based on the cursor's context within the
-// call. Dismisses on no-signature responses and on Escape (handled at
-// the SmartEditor level via `clearSignature`).
-//
-// Position-mapping mirrors useLspSemanticTokens: pure offset math via
-// the converter. Hook returns `{signature, position, clearSignature}`.
-
-import { debounce } from 'lodash';
-import {
-  RefObject,
-  useCallback,
-  useEffect,
-  useMemo,
-  useRef,
-  useState,
-} from 'react';
-import { BaseEditor, Editor } from 'slate';
-import { HistoryEditor } from 'slate-history';
-import { ReactEditor } from 'slate-react';
-import { ILspSignatureHelp } from '../../utils/lspClient.types';
-import { offsetToLspPosition } from './helpers';
-import { ISlateConverter, ISlateElement } from './types';
-import type { IUseLspSessionResult } from './useLspSession';
-
-export interface IUseLspSignatureHelpOptions {
-  /** Default `true`. Set to `false` to disable. */
-  enabled?: boolean;
-  /** Debounce window before issuing the LSP request. Default 100ms. */
-  debounceMs?: number;
-}
-
-export interface IUseLspSignatureHelpResult {
-  /** Response from the LSP, or `null` when no signature available. */
-  signature: ILspSignatureHelp | null;
-  /** Viewport-coordinate anchor for the signature pill (top of cursor line). */
-  position: { left: number; top: number } | null;
-  /** Imperatively dismiss the current signature pill. */
-  clearSignature: () => void;
-}
-
-export function useLspSignatureHelp(
-  session: IUseLspSessionResult,
-  editorRef: RefObject<
-    (BaseEditor & ReactEditor & HistoryEditor) | null
-  >,
-  converter: ISlateConverter,
-  nodes: ISlateElement[],
-  options: IUseLspSignatureHelpOptions = {}
-): IUseLspSignatureHelpResult {
-  const { enabled = true, debounceMs = 100 } = options;
-
-  const [signature, setSignature] = useState<ILspSignatureHelp | null>(null);
-  const [position, setPosition] = useState<{
-    left: number;
-    top: number;
-  } | null>(null);
-
-  // Track latest in-flight request so a slow response can't overwrite
-  // newer state.
-  const requestIdRef = useRef(0);
-
-  const clearSignature = useCallback(() => {
-    setSignature(null);
-    setPosition(null);
-  }, []);
-
-  // Pre-compute plain text from the slate document. Same memo
-  // pattern as useLspSemanticTokens.
-  const plainText = useMemo(
-    () => converter.fromSlateNodes(nodes),
-    [converter, nodes]
-  );
-
-  // Debounced fetch. Re-created via the effect below to capture the
-  // latest session/plainText/etc. Started as a no-op so the ref is
-  // always a function.
-  const fetchSignature = useRef<ReturnType<typeof debounce>>(
-    debounce(() => undefined)
-  );
-
-  // Depend on stable primitives inside `session` (not `session`
-  // itself, which is rebuilt every render — `useLspSession` returns a
-  // fresh object).
-  useEffect(() => {
-    fetchSignature.current.cancel();
-    fetchSignature.current = debounce(async () => {
-      const editor = editorRef.current;
-      const client = session.client;
-      if (
-        !enabled ||
-        !editor ||
-        !client ||
-        !session.isReady ||
-        !session.isContextReady ||
-        !session.capabilities?.signatureHelpProvider
-      ) {
-        clearSignature();
-        return;
-      }
-      // If the editor doesn't have a focused selection (e.g. fresh
-      // mount before user interaction), fall back to the end of the
-      // document. Without this, the hook would never fire on mount
-      // — the demo story can't ask the user to click first.
-      let selection = editor.selection;
-      if (!selection) {
-        try {
-          const end = Editor.end(editor, []);
-          selection = { anchor: end, focus: end };
-        } catch {
-          clearSignature();
-          return;
-        }
-      }
-
-      // Map the current selection's anchor to an LSP {line, character}.
-      const currentNodes = editor.children as ISlateElement[];
-      const text = converter.fromSlateNodes(currentNodes);
-      const offset = converter.selectionToOffset(
-        currentNodes,
-        selection.anchor.path as number[],
-        selection.anchor.offset
-      );
-      const { line, character } = offsetToLspPosition(text, offset);
-
-      const reqId = ++requestIdRef.current;
-      try {
-        const result = await client.getSignatureHelp(line, character);
-        if (reqId !== requestIdRef.current) return; // stale
-        // LSP servers signal "no signature" either by responding `null`
-        // or by responding `{signatures: []}` — treat both as dismiss.
-        if (!result || !result.signatures || result.signatures.length === 0) {
-          clearSignature();
-          return;
-        }
-        setSignature(result);
-        // Anchor the pill ABOVE the current cursor line so it
-        // doesn't overlap the completion popover, which anchors at
-        // BELOW the line. The two can coexist on a single line
-        // when a function call's args are mid-typed.
-        try {
-          const domRange = ReactEditor.toDOMRange(editor, selection);
-          const rect = domRange.getBoundingClientRect();
-          if (rect.width || rect.height || rect.left || rect.top) {
-            setPosition({ left: rect.left, top: rect.top - 4 });
-          }
-        } catch {
-          // Editor unmounted mid-request — keep last-known position.
-        }
-      } catch {
-        if (reqId === requestIdRef.current) clearSignature();
-      }
-    }, debounceMs);
-    return () => fetchSignature.current.cancel();
-  }, [
-    session.client,
-    session.isReady,
-    session.isContextReady,
-    session.capabilities,
-    converter,
-    enabled,
-    debounceMs,
-    editorRef,
-    clearSignature,
-  ]);
-
-  // Fire on document changes (text content) AND when the session
-  // becomes ready/capabilities arrive. The signature-help request
-  // itself reads the live selection from `editorRef.current` so
-  // cursor-only moves are picked up too — SmartEditor's
-  // `onSlateChangeImpl` triggers a render on every Slate change,
-  // which re-runs this effect's deps closure (plainText changes
-  // when content does) and the editor's selection is read inside
-  // the debounced fetch.
-  useEffect(() => {
-    if (
-      !enabled ||
-      !session.isReady ||
-      !session.isContextReady ||
-      !session.capabilities?.signatureHelpProvider
-    ) {
-      return;
-    }
-    fetchSignature.current();
-  }, [
-    enabled,
-    session.isReady,
-    session.isContextReady,
-    session.capabilities,
-    plainText,
-  ]);
-
-  return { signature, position, clearSignature };
-}

package/src/components/supportTicket/AttachmentChips.stories.tsx

@@ -1,171 +0,0 @@
-import { StoryObj } from '@storybook/react-vite';
-import { useState } from 'react';
-import { expect, userEvent, waitFor, within } from 'storybook/test';
-import { StoryMeta } from '../../types';
-import { AttachmentChips } from './AttachmentChips';
-
-/**
- * Staged-file chips for a ticket composer. Image files show a thumbnail and open the shared
- * `ImageLightbox` on click; other files show a paperclip. The pencil renames a file inline
- * (a File name is read-only, so the host swaps in a renamed copy); the ✕ removes it.
- */
-const meta = {
-  component: AttachmentChips,
-  title: 'Components/AttachmentChips',
-} as StoryMeta<typeof AttachmentChips>;
-export default meta;
-type Story = StoryObj<typeof meta>;
-
-const imageFile = (label: string, hue: number, name: string): File => {
-  const svg =
-    `<svg xmlns='http://www.w3.org/2000/svg' width='640' height='400'>` +
-    `<rect width='640' height='400' fill='hsl(${hue},40%,16%)'/>` +
-    `<text x='24' y='210' fill='white' font-family='sans-serif' font-size='30'>${label}</text></svg>`;
-  return new File([svg], name, { type: 'image/svg+xml' });
-};
-const textFile = (name: string): File => new File(['log contents'], name, { type: 'text/plain' });
-
-const FILES = [
-  imageFile('before', 265, 'screenshot-2026-07-26-17-41-44.png'),
-  imageFile('after', 205, 'canvas-after.png'),
-  textFile('server.log'),
-];
-
-// Plays the composer's role: owns the file set, swaps in a renamed copy on rename.
-const Harness = () => {
-  const [files, setFiles] = useState<File[]>(FILES);
-  return (
-    <AttachmentChips
-      files={files}
-      onRemove={(index) => setFiles((current) => current.filter((_, j) => j !== index))}
-      onRename={(index, name) =>
-        setFiles((current) =>
-          current.map((file, i) => (i === index ? new File([file], name, { type: file.type }) : file))
-        )
-      }
-    />
-  );
-};
-
-/**
- * Two screenshots + a log. Clicking a screenshot chip opens the lightbox (paging across the two
- * images); the log stays a plain chip. Proves the preview opens and paints the image.
- */
-export const WithImages: Story = {
-  parameters: {
-    docs: {
-      description: {
-        story:
-          'Renders staged chips for two screenshots and a log, where clicking a screenshot chip opens the shared lightbox while the log stays a plain chip.',
-      },
-    },
-  },
-  render: () => <Harness />,
-  play: async ({ canvasElement }) => {
-    const canvas = within(canvasElement);
-    await expect(canvas.getByText('screenshot-2026-07-26-17-41-44.png')).toBeInTheDocument();
-    await expect(canvas.getByText('server.log')).toBeInTheDocument();
-
-    // clicking an image chip opens the shared lightbox (portals to the body)
-    await userEvent.click(canvas.getByText('canvas-after.png'));
-    await waitFor(() => expect(document.querySelector('[role="dialog"]')).not.toBeNull());
-    await waitFor(() =>
-      expect(document.body.querySelector('img[alt="canvas-after.png"]')).not.toBeNull()
-    );
-  },
-};
-
-/**
- * Renaming from INSIDE the preview: open a chip's lightbox, use its pencil, and the new
- * name lands on the chip too — the lightbox funnels into the same host `onRename` as the
- * chip pencil, so both affordances stay one mechanism.
- */
-export const RenameFromPreview: Story = {
-  parameters: {
-    docs: {
-      description: {
-        story:
-          'Renders the staged chips and renames a screenshot from inside its lightbox — the preview’s pencil commits the new name, and the chip outside carries it too.',
-      },
-    },
-  },
-  render: () => <Harness />,
-  play: async ({ canvasElement }) => {
-    const canvas = within(canvasElement);
-    await userEvent.click(canvas.getByText('canvas-after.png'));
-    await waitFor(() => expect(document.querySelector('[role="dialog"]')).not.toBeNull());
-
-    const pencil = await waitFor(() => {
-      const el = document.body.querySelector<HTMLButtonElement>('.imagelightbox-rename');
-      if (!el) {
-        throw new Error('lightbox rename action not rendered');
-      }
-      return el;
-    });
-    await userEvent.click(pencil);
-    const input = await waitFor(() => {
-      const el = document.body.querySelector<HTMLInputElement>('.reqore-modal input');
-      if (!el) {
-        throw new Error('lightbox rename input not shown');
-      }
-      return el;
-    });
-    await userEvent.clear(input);
-    await userEvent.type(input, 'after-fix.png');
-    await userEvent.keyboard('{Enter}');
-
-    // commit ends the edit; a second Esc now closes the modal itself
-    await userEvent.keyboard('{Escape}');
-    await waitFor(() => expect(document.querySelector('[role="dialog"]')).toBeNull());
-
-    // the rename reached the host: the CHIP carries the new name
-    await waitFor(() => expect(canvas.getByText('after-fix.png')).toBeInTheDocument());
-    await expect(canvas.queryByText('canvas-after.png')).not.toBeInTheDocument();
-  },
-};
-
-/**
- * Renaming an auto-named screenshot: the pencil turns the chip into an inline input; Enter
- * commits and the chip shows the new name. Discriminating — remove the rename wiring and the
- * chip keeps its `screenshot-<timestamp>.png` name.
- */
-export const Rename: Story = {
-  parameters: {
-    docs: {
-      description: {
-        story:
-          'Renders the staged chips and renames an auto-named screenshot inline — the pencil opens an input, Enter commits, and the chip shows the new name.',
-      },
-    },
-  },
-  render: () => <Harness />,
-  play: async ({ canvasElement }) => {
-    const canvas = within(canvasElement);
-    const chip = canvas.getByText('screenshot-2026-07-26-17-41-44.png').closest('.reqore-tag');
-    if (!chip) {
-      throw new Error('chip not found');
-    }
-    // click the rename pencil (its own action; the ✕ is a separate reqore-tag-remove)
-    const renameAction = chip.querySelector<HTMLElement>('.reqore-tag-action:not(.reqore-tag-remove)');
-    if (!renameAction) {
-      throw new Error('rename action not rendered');
-    }
-    await userEvent.click(renameAction);
-
-    // the inline input appears, pre-filled with the current name
-    const input = await waitFor(() => {
-      const el = canvasElement.querySelector<HTMLInputElement>('input');
-      if (!el) {
-        throw new Error('rename input not shown');
-      }
-      return el;
-    });
-    await userEvent.clear(input);
-    await userEvent.type(input, 'mapper-error.png');
-    await userEvent.keyboard('{Enter}');
-
-    // the chip now carries the new name; the auto-name is gone
-    await waitFor(() => expect(canvas.getByText('mapper-error.png')).toBeInTheDocument());
-    await expect(canvas.queryByText('screenshot-2026-07-26-17-41-44.png')).not.toBeInTheDocument();
-  },
-};