@qoretechnologies/reqraft 0.10.58-pr.129.gd317f2e → 0.10.58

package/src/components/form/expressions/builder/index.tsx

@@ -24,13 +24,18 @@ import { darken, rgba } from 'polished';
 import React, { useCallback, useEffect, useMemo, useRef, useState } from 'react';
 import styled from 'styled-components';
 import { moveItem } from '../../../../helpers/common';
-import { areQorusTypesCompatible, getArgumentType } from '../../../../helpers/expressions';
+import {
+  areQorusTypesCompatible,
+  expressionFitsReturnType,
+  getArgumentType,
+} from '../../../../helpers/expressions';
 import { addMissingExpressionArgs } from '../argumentPresence';
 import { findTemplate } from '../../../../helpers/templates';
 import { validateField, validateFieldWithResult } from '../../../../helpers/validations';
 import { IQorusTypeObject, useQorusTypes } from '../../../../hooks/useQorusTypes';
 import { useReqraftStorage } from '../../../../hooks/useStorage/useStorage';
 import { usePhoneViewport } from '../../../../hooks/usePhoneViewport';
+import { useCoarsePointer } from '../../../../hooks/useCoarsePointer';
 import { useTemplates } from '../../../../hooks/useTemplates';
 import { AutoFormField as auto } from '../../fields/auto/AutoFormField';
 import { SelectFormField as Select } from '../../fields/select/Select';
@@ -148,6 +153,7 @@ export const Expression = ({
   componentOverrides,
   ...props
 }: IExpressionProps) => {
+  const coarsePointer = useCoarsePointer();
   const types = useQorusTypes();
   const [showSummary, setShowSummary] = useState(false);
   const [confirmDialogData, setConfirmDialogData] = useState<
@@ -594,6 +600,15 @@ export const Expression = ({
   const defaultItems = useMemo(
     () =>
       expressions.value
+        // a condition (a field or an operand that must be true or false) offers the operations that
+        // give true or false; a group's members are its own business, and the operation already chosen
+        // stays, so a stored mismatch can be seen and fixed
+        .filter(
+          (exp) =>
+            isChild ||
+            exp.name === value?.value?.exp ||
+            expressionFitsReturnType(returnType as string | string[] | undefined, exp)
+        )
         .map((exp) => ({
           name: exp.name,
           value: exp.name,
@@ -612,7 +627,7 @@ export const Expression = ({
               ? !exp.from_server
               : true
         ),
-    [JSON.stringify(expressions.value), serverExpression, level]
+    [JSON.stringify(expressions.value), serverExpression, level, isChild, returnType, value?.value?.exp]
   );
 
   // SEAM (reqraft): reqraft's `SelectFormField` calls `onChange(value)` with
@@ -879,7 +894,10 @@ export const Expression = ({
       contentStyle={{
         overflowX: 'hidden',
       }}
-      floatingActions
+      // with a mouse, the actions float above the panel while it is hovered; a finger cannot hover, and a
+      // tap left them floating over what is above - the Visual / Text switch, where a tap meant for
+      // Text hit "Remove this expression" - so on a touch device they stay in the panel's own bar
+      floatingActions={!coarsePointer}
       actions={[
         // SEAM (reqraft): the IDE renders `AiAssistanceAction` first here;
         // consumers inject it (or anything else) via `extraActions`.

package/src/components/form/fields/emittedValues.ts

@@ -36,6 +36,14 @@ export class EmittedValues<T> {
     }
   }
 
+  /**
+   * Whether `incoming` is one of the emits still in flight, without acknowledging anything: for a render,
+   * which may run more than once for one value, while `isEcho` is called once the value is committed.
+   */
+  includes(incoming: T): boolean {
+    return this.pending.some((value) => this.equals(value, incoming));
+  }
+
   /**
    * Whether `incoming` is the echo of an emit still in flight. An echo
    * acknowledges that emit and every earlier one; anything else clears the

package/src/components/form/fields/template/TemplateField.tsx

@@ -803,7 +803,10 @@ const TemplateFieldImpl = memo(
       }
     }, [JSON.stringify(templateValue)]);
 
-    const showTemplateToggle = allowCustomValues && allowTemplates && !rest.arg_schema;
+    // an editor that takes templates into its own text has no template mode to switch to: "Use Template"
+    // there emptied the field and showed nothing in its place
+    const showTemplateToggle =
+      allowCustomValues && allowTemplates && !rest.arg_schema && !editorHandlesTemplates;
 
     // Only a BRACED context ref (`$data:{…}` — machine-written, nobody types
     // one) renders as the picker chip (named via `resolveTemplateLabel`)

package/src/components/smartEditor/SmartEditor.tsx

@@ -31,6 +31,7 @@ import React, {
 import { Editor, NodeEntry, Range, Transforms } from 'slate';
 import { ReactEditor, RenderLeafProps } from 'slate-react';
 import { ILspSignatureHelp } from '../../utils/lspClient.types';
+import { useEmittedValues } from '../form/fields/emittedValues';
 import { defaultSlateConverter, expandSnippet, lspPositionToOffset } from './helpers';
 import { MarkdownDoc } from './MarkdownDoc';
 import { COMPLETION_KIND_INTENTS, SMART_EDITOR_OVERLAY_EFFECT } from './styling';
@@ -359,9 +360,25 @@ export const SmartEditor = forwardRef<TReqoreRichTextEditorRef, ISmartEditorProp
       enabled: enableHover,
     });
 
+    /* What the editor has reported and the host has not handed back yet. A host can hand an emit back
+       after the next key is already in the editor - one that debounces, or a render that lands between
+       two keys - and that stale value is not a change: rebuilding the document from it replaced the text
+       and put the caret at its end, so the next key followed the stale text (`name` typed came out
+       `nae`). See `EmittedValues`. */
+    const emitted = useEmittedValues<string>();
+    /* The value the host last handed down. The editor re-renders between keys for its own reasons (it
+       has just reported a new tree), and the host has not caught up then: the value it still holds is
+       not a change either. */
+    // nothing until the first value is committed, so the server is sent the first value too
+    const committedValueRef = useRef<string | undefined>(undefined);
+
     const slateValue = useMemo(() => {
-      // Reuse the cache when `value` is just the editor's own typing echo.
-      if (slateValueRef.current !== null && value === lastPlainTextRef.current) {
+      // Reuse the cache unless the host handed down something new: the same value again, the editor's
+      // own typing echo - the latest, or one still in flight - is not
+      if (
+        slateValueRef.current !== null &&
+        (value === committedValueRef.current || value === lastPlainTextRef.current || emitted.includes(value))
+      ) {
         return slateValueRef.current;
       }
       const next = converter.toSlateNodes(value);
@@ -376,8 +393,14 @@ export const SmartEditor = forwardRef<TReqoreRichTextEditorRef, ISmartEditorProp
        this one; typing already sent its text, and is not resent. */
     const { didChange: syncDocument } = session;
     useEffect(() => {
+      // the echo of an emit is acknowledged, and is not sent: the server already has the newer text
+      // typing sent; anything else is a change from outside
+      if (committedValueRef.current === value) return;
+      committedValueRef.current = value;
+      if (emitted.isEcho(value)) return;
+      lastPlainTextRef.current = value;
       syncDocument(value);
-    }, [syncDocument, value]);
+    }, [syncDocument, value, emitted]);
 
     const diagnosticDecorate = useLspDiagnosticDecorations(
       session.diagnostics,
@@ -486,6 +509,7 @@ export const SmartEditor = forwardRef<TReqoreRichTextEditorRef, ISmartEditorProp
 
         if (plainText !== lastPlainTextRef.current) {
           lastPlainTextRef.current = plainText;
+          emitted.record(plainText);
           // CRITICAL: the next render's `value` equals `lastPlainTextRef` (the
           // typing echo), so `slateValue`'s cache returns the live nodes set
           // above — leave them stale and downstream hooks (signature help,
@@ -499,7 +523,7 @@ export const SmartEditor = forwardRef<TReqoreRichTextEditorRef, ISmartEditorProp
           autocomplete.onSlateChange(editorRef.current as any, newNodes);
         }
       },
-      [onChange, session, readOnly, autocomplete, converter]
+      [onChange, session, readOnly, autocomplete, converter, emitted]
     );
 
     // Replace mode: open the dropdown at the chip's DOM rect (not the

package/src/components/smartEditor/useLspSession.ts

@@ -132,6 +132,8 @@ export function useLspSession(
 
     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
@@ -152,12 +154,18 @@ export function useLspSession(
         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;

package/src/helpers/allowedValues.ts

@@ -0,0 +1,216 @@
+/**
+ * Is a stored value one of a field's fixed choices?
+ *
+ * Two questions share this one predicate: the read-first row asks it to LABEL a
+ * value with the choice's display name, and the validator asks it to decide
+ * whether a value is one of the choices at all. Answering them differently is
+ * how values were lost: a value the row could name was erased by a narrower
+ * test, and the emptied form was then saved.
+ */
+import { TQorusFormFieldSchema } from '@qoretechnologies/ts-toolkit';
+import isEqual from 'lodash/isEqual';
+import { richtextHasTag, richtextToString } from './common';
+import { getListElementValue } from './options';
+import { isValueTemplate } from './templates';
+
+const isStructured = (value: unknown): boolean => value !== null && typeof value === 'object';
+
+/**
+ * Prefer the matching allowed_values entry's display_name (fallback `name`)
+ * over the raw stored value.
+ *
+ * A LIST carries its options under `element_allowed_values` — they constrain
+ * each element, not the list itself — so a multi-select that was missing here
+ * printed what it stores rather than what you picked: `orders, batch` for
+ * fields whose picker reads "Orders, Batch". The gap shows worst exactly where
+ * allowed values earn their keep, since the stored form is often not readable
+ * at all (a permission code, `PO_REQUIRE_TYPES`, an app-specific id).
+ *
+ * Exported (as `findAllowedValueOption`) because the form engine's value
+ * validation has to answer the SAME question — "is this stored value one of the
+ * declared choices?" — and answering it differently loses data. An
+ * `allowed_values` entry is written three ways: an envelope (`{value: {type,
+ * value}}`), a bare value (`{value: 'default'}`) or a named entry
+ * (`{name: 'default'}`). This has always accepted all three; the engine's
+ * clearing guard accepted only the first and the third, so a schema using the
+ * bare form had its value ERASED on load while this function went on rendering
+ * the display name for it — the row read "Default RBAC" collapsed and "—" when
+ * opened, and the value was gone from the submitted data.
+ */
+export const findAllowedValueOption = (
+  value: unknown,
+  schema?: TQorusFormFieldSchema
+): any | undefined => {
+  const s = schema as
+    { allowed_values?: any[]; element_allowed_values?: any[]; items?: any[] } | undefined;
+  const options =
+    (s?.allowed_values?.length && s.allowed_values) ||
+    (s?.element_allowed_values?.length && s.element_allowed_values) ||
+    s?.items;
+  if (!options?.length) {
+    return undefined;
+  }
+  // A stored element can be the bare value or the typed `{type, value}`
+  // envelope the form engine round-trips; match either against either.
+  const stored =
+    value && typeof value === 'object' && 'value' in (value as Record<string, unknown>) ?
+      (value as Record<string, unknown>).value
+    : value;
+
+  // A rich-text document is its text: a field with fixed choices can hold the document an editor wrote
+  // (for example while its choices could not be loaded), and the document for "Case" is the choice "Case".
+  const text = Array.isArray(stored) ? richtextToString(stored as never) : undefined;
+
+  return options.find(
+    (option) =>
+      option?.value?.value === value ||
+      option?.value === value ||
+      option?.name === value ||
+      option?.value?.value === stored ||
+      option?.value === stored ||
+      option?.name === stored ||
+      (text !== undefined &&
+        (option?.value?.value === text || option?.value === text || option?.name === text)) ||
+      // A hash- or list-valued choice is a fresh object every time the schema
+      // arrives, so identity can never match it; its contents can.
+      (isStructured(stored) &&
+        (isEqual(option?.value?.value, stored) || isEqual(option?.value, stored)))
+  );
+};
+
+/**
+ * A Slate rich-text document: a non-empty array of element nodes, each with
+ * `children`. Told apart from a LIST value, which is an array of elements.
+ */
+const isRichTextDocument = (value: unknown): boolean =>
+  Array.isArray(value) &&
+  value.length > 0 &&
+  value.every(
+    (node) => !!node && typeof node === 'object' && Array.isArray((node as any).children)
+  );
+
+/** A value resolved only when the interface runs — never one of the choices. */
+const isResolvedAtRunTime = (value: unknown): boolean =>
+  (typeof value === 'string' && isValueTemplate(value)) || richtextHasTag(value);
+
+const isEmptyChoiceValue = (value: unknown): boolean =>
+  value === undefined ||
+  value === null ||
+  value === '' ||
+  (Array.isArray(value) && value.length === 0);
+
+/** The fields of a schema entry the choice check reads. */
+export interface IChoiceFieldSchema {
+  allowed_values?: any[];
+  allowed_values_creatable?: boolean;
+  element_allowed_values?: any[];
+  element_allowed_values_creatable?: boolean;
+  multiselect?: boolean;
+  /** Set when the value is an expression, which is resolved at run time. */
+  isFunction?: boolean;
+  is_expression?: boolean;
+}
+
+/**
+ * The parts of a stored value that are not among the field's fixed choices.
+ *
+ * Empty when the value is acceptable, or when there is nothing to judge it
+ * against:
+ * - an empty value (whether one is needed is the required check's question);
+ * - an expression, a template string or a document holding a template tag,
+ *   all of which are resolved when the interface runs;
+ * - `allowed_values: []` — the server has no choices to offer right now, which
+ *   is "unknown", not "nothing is allowed";
+ * - creatable choices, where any value may be added.
+ *
+ * A single-valued field is judged as a whole. A multi-select field, and a list
+ * whose elements are constrained by `element_allowed_values`, are judged per
+ * element, so the answer names exactly the elements that are not choices.
+ */
+export const getUnlistedChoices = (value: unknown, field?: IChoiceFieldSchema): unknown[] => {
+  if (!field || isEmptyChoiceValue(value) || field.isFunction || field.is_expression) {
+    return [];
+  }
+
+  const judgeElements = (elements: unknown[], choices: any[]): unknown[] =>
+    elements.filter((element) => {
+      const stored = getListElementValue(element);
+      if (isEmptyChoiceValue(stored) || isResolvedAtRunTime(stored)) {
+        return false;
+      }
+      if ((element as { is_expression?: boolean })?.is_expression) {
+        return false;
+      }
+      return !findAllowedValueOption(element, { allowed_values: choices } as never);
+    });
+
+  if (isResolvedAtRunTime(value)) {
+    return [];
+  }
+
+  if (field.allowed_values?.length && !field.allowed_values_creatable) {
+    if (findAllowedValueOption(value, { allowed_values: field.allowed_values } as never)) {
+      return [];
+    }
+    // A multi-select holds a list of choices; any list that is not itself a
+    // choice is judged element by element.
+    if (Array.isArray(value) && !isRichTextDocument(value)) {
+      return judgeElements(value, field.allowed_values);
+    }
+    return [value];
+  }
+
+  if (
+    field.element_allowed_values?.length &&
+    !field.element_allowed_values_creatable &&
+    !field.allowed_values_creatable &&
+    Array.isArray(value) &&
+    !isRichTextDocument(value)
+  ) {
+    return judgeElements(value, field.element_allowed_values);
+  }
+
+  return [];
+};
+
+/** How a value not among the choices is named in the message. */
+const describeChoiceValue = (value: unknown): string => {
+  const stored = getListElementValue(value);
+  if (typeof stored === 'string') {
+    return stored;
+  }
+  if (isRichTextDocument(stored)) {
+    return richtextToString(stored as never);
+  }
+  if (stored === null || typeof stored !== 'object') {
+    return String(stored);
+  }
+  try {
+    return JSON.stringify(stored);
+  } catch {
+    return String(stored);
+  }
+};
+
+/**
+ * Why a stored value is not acceptable for a field with fixed choices, or
+ * `undefined` when it is (see {@link getUnlistedChoices} for what is judged).
+ *
+ * The value is kept — it is never erased for not being a choice — and this
+ * reason is what makes the field invalid, so the form shows it under "Needs
+ * attention" and blocks submitting until the author picks a choice.
+ */
+export const getUnlistedChoiceReason = (
+  value: unknown,
+  field?: IChoiceFieldSchema
+): string | undefined => {
+  const unlisted = getUnlistedChoices(value, field);
+  if (!unlisted.length) {
+    return undefined;
+  }
+  const names = unlisted.map((item) => `"${describeChoiceValue(item)}"`);
+  if (names.length === 1) {
+    return `${names[0]} is not one of the choices`;
+  }
+  return `${names.slice(0, -1).join(', ')} and ${names[names.length - 1]} are not among the choices`;
+};

package/src/helpers/common.ts

@@ -93,6 +93,20 @@ export const getDefaultValue = (schema?: TQorusFormFieldSchema): unknown | undef
   return undefined;
 };
 
+/**
+ * Whether a rich-text document contains a template tag (a `$local:...`-style reference drawn as a chip).
+ *
+ * Such a value is resolved when the interface runs, so it can never be one of a field's fixed choices and must
+ * not be judged against them.
+ */
+export const richtextHasTag = (richtext: unknown): boolean => {
+  const walk = (node: any): boolean =>
+    !!node &&
+    typeof node === 'object' &&
+    (node.type === 'tag' || (Array.isArray(node.children) && node.children.some(walk)));
+  return Array.isArray(richtext) && richtext.some(walk);
+};
+
 export const richtextToString = (richtext: IReqoreRichTextEditorProps['value']): string => {
   // A `richtext` ui_type option can still hold a plain scalar value (set
   // programmatically or loaded from the server before the editor ever touched

package/src/helpers/expressions.ts

@@ -100,3 +100,28 @@ export const areQorusTypesCompatible = (
   // If none of the types are compatible return false
   return false;
 };
+
+/**
+ * Whether an operation is offered where its result must be of `returnType`: a condition (`bool`) is
+ * built from the operations that give true or false, not from every operation the server has.
+ *
+ * Only a condition narrows the list. Any other type keeps every operation: a value of one type is often
+ * made from an operation that gives another (text from rich text, a number from an int), and the
+ * mismatch message after the choice says when it does not fit.  An operation whose result is known
+ * only once it is built (`any`, or the type of its first argument) is offered everywhere.
+ */
+export const expressionFitsReturnType = (
+  returnType: string | string[] | undefined,
+  expression: { ui_return_type?: string; return_type_first_arg?: boolean }
+): boolean => {
+  const types = isArray(returnType) ? returnType : returnType ? [returnType] : [];
+  const condition = types.length > 0 && types.every((type) => /^\*?(bool|boolean)$/.test(type));
+  if (!condition) {
+    return true;
+  }
+  const result = expression.ui_return_type;
+  if (expression.return_type_first_arg || !result || result === 'any' || result === 'auto') {
+    return true;
+  }
+  return /^\*?(bool|boolean)$/.test(result);
+};

package/src/helpers/validations.ts

@@ -16,6 +16,7 @@ import { isOptionInterfaceUiType } from './optionUiTypes';
 import { getListElementValue, getOptionsFromRequiredGroups } from './options';
 import { IProviderType, TVariableActionValue, maybeBuildOptionProvider } from './providerValue';
 import { getTemplateKey, getTemplateValue, isValueTemplate } from './templates';
+import { getUnlistedChoiceReason } from './allowedValues';
 
 /** The five cron fields, in order, as a schedule hash may name them. */
 const CRON_FIELDS: [string, string][] = [
@@ -309,6 +310,21 @@ export const _validateField = (
     }
   }
 
+  // A value that is not one of the field's fixed choices is INVALID — never
+  // erased. The form used to drop such a value when the choices arrived, and
+  // three times the dropped value was a real one (a document naming a choice,
+  // a bare-declared choice, a value whose choices had not loaded yet) that the
+  // emptied form then saved. Keeping it and saying why it cannot be submitted
+  // leaves the author to decide. Templates and expression values returned
+  // above; `allowed_values: []` and creatable choices are not judged. An
+  // `expression` is never judged either: the expression branch above recurses
+  // here with the field's schema (choices included) and the AST as the value.
+  const unlistedChoiceReason =
+    type === 'expression' ? undefined : getUnlistedChoiceReason(value, field);
+  if (unlistedChoiceReason) {
+    return invalidResult(unlistedChoiceReason);
+  }
+
   // An interface type names another Qorus object by its name, so a non-empty
   // string is the whole contract. `connection` is the exception: it carries
   // enablement and authentication state of its own, checked below.

package/src/hooks/useCoarsePointer.ts

@@ -0,0 +1,30 @@
+// Copyright 2026 Qore Technologies, s.r.o.
+import { useEffect, useState } from 'react';
+
+/** The pointer a finger is: it cannot hover. */
+export const COARSE_POINTER_QUERY = '(pointer: coarse)';
+
+/**
+ * Whether the primary pointer is coarse (a finger), from the media query itself.
+ *
+ * Starts `false` and settles after mount, so a server render and the first paint agree.
+ */
+export const useCoarsePointer = (): boolean => {
+  const [coarse, setCoarse] = useState<boolean>(false);
+
+  useEffect(() => {
+    if (typeof window === 'undefined' || !window.matchMedia) {
+      return undefined;
+    }
+
+    const query = window.matchMedia(COARSE_POINTER_QUERY);
+    const sync = () => setCoarse(query.matches);
+
+    sync();
+    query.addEventListener?.('change', sync);
+
+    return () => query.removeEventListener?.('change', sync);
+  }, []);
+
+  return coarse;
+};

package/src/utils/fetch.ts

@@ -12,6 +12,10 @@ export interface IReqraftFetchResponse<T> {
   data: T;
   ok: boolean;
   code?: number;
+  /**
+   * Set on every non-ok response: the HTTP reason phrase, or `HTTP <status>`
+   * when there is none (always the case over HTTP/2).
+   */
   error?: any;
   /**
    * The parsed error body on a non-ok response, when the server sent JSON.
@@ -335,7 +339,12 @@ export async function query<T>({
       data: requestData.data,
       ok: false,
       code: requestData.status,
-      error: requestData.statusText,
+      // Never empty: HTTP/2 has no reason phrase, so `statusText` is always ''
+      // there, and an empty `error` reads as "no error" to every caller that
+      // tests it for truthiness - `useFetch` consumers then saw a failed request
+      // as one still loading, forever (a 403 left a dashboard panel on its
+      // skeleton).
+      error: requestData.statusText || `HTTP ${requestData.status}`,
       // Only when the body really was JSON: `data` is `{}` for a non-JSON body,
       // and an empty object masquerading as a parsed error tells a caller
       // nothing while looking like it did.