@qoretechnologies/reqraft 0.10.64 → 0.10.65-pr.137.g62fcecc

package/src/components/form/expressions/mockExpressions.ts

@@ -1,317 +0,0 @@
-// Copyright 2026 Qore Technologies, s.r.o.
-// An expression-catalogue fixture for stories / tests — a faithful subset of
-// the real `GET /system?action=expressions&context=ui` payload (captured
-// live), so the offline stories render the same operand types, operator
-// words (`label_after`), and group structure as the live IDE. Not all 121
-// entries — the ones the stories exercise.
-import { IExpressionSchema } from './types';
-
-// String comparators share this arg shape: a richtext value (with the
-// operator word as `label_after`), a richtext operand, and an Ignore Case flag.
-const stringArgs = (
-  operandLabel: string,
-  operatorWord: string
-): IExpressionSchema['args'] => [
-  {
-    name: 'softstring',
-    display_name: 'String Value',
-    ui_type: 'richtext',
-    required: true,
-    label_after: operatorWord,
-  },
-  { name: 'softstring', display_name: operandLabel, ui_type: 'richtext', required: true },
-  {
-    name: 'bool',
-    display_name: 'Ignore Case?',
-    ui_type: 'bool',
-    required: true,
-    default_value: true,
-  },
-];
-
-// Binary comparators on `any`: a value, the operator word, another value.
-const comparatorArgs = (operatorWord: string): IExpressionSchema['args'] => [
-  { name: 'any', display_name: 'Value', ui_type: 'any', required: true, label_after: operatorWord },
-  { name: 'any', display_name: 'Value', ui_type: 'any', required: true },
-];
-
-export const mockExpressions: IExpressionSchema[] = [
-  {
-    name: '==',
-    display_name: 'Logical Equals',
-    short_desc: 'Returns True if the two arguments are logically equal',
-    desc: 'Returns `True` if the two arguments are logically equal; types are converted if necessary.',
-    symbol: '==',
-    type: 1,
-    subtype: 1,
-    return_type: 'bool',
-    ui_return_type: 'bool',
-    varargs: false,
-    groups: ['Comparison'],
-    args: comparatorArgs('=='),
-  },
-  {
-    name: '<',
-    display_name: 'Logical Less Than',
-    short_desc: 'Returns True if the first argument is less than the second',
-    desc: 'Returns `True` if the first argument is less than the second.',
-    symbol: '<',
-    type: 1,
-    subtype: 1,
-    return_type: 'bool',
-    ui_return_type: 'bool',
-    varargs: false,
-    groups: ['Comparison'],
-    args: comparatorArgs('<'),
-  },
-  {
-    name: '>=',
-    display_name: 'Logical Greater Than Or Equal',
-    short_desc: 'Returns True if the first argument is greater than or equal to the second',
-    desc: 'Returns `True` if the first argument is greater than or equal to the second.',
-    symbol: '>=',
-    type: 1,
-    subtype: 1,
-    return_type: 'bool',
-    ui_return_type: 'bool',
-    varargs: false,
-    groups: ['Comparison'],
-    args: comparatorArgs('>='),
-  },
-  {
-    name: '&&',
-    display_name: 'Logical And',
-    short_desc: 'Returns True if all arguments are True with logic short-circuiting',
-    desc: 'Logical AND of all arguments, with short-circuiting.',
-    symbol: '&&',
-    type: 1,
-    subtype: 2,
-    return_type: 'bool',
-    ui_return_type: 'bool',
-    varargs: true,
-    min_args: 1,
-    groups: ['Logic'],
-    args: [{ name: 'bool', display_name: 'Value', ui_type: 'bool', required: true }],
-  },
-  {
-    name: '||',
-    display_name: 'Logical Or',
-    short_desc: 'Returns True if at least one argument is True with logic short-circuiting',
-    desc: 'Logical OR of all arguments, with short-circuiting.',
-    symbol: '||',
-    type: 1,
-    subtype: 2,
-    return_type: 'bool',
-    ui_return_type: 'bool',
-    varargs: true,
-    min_args: 1,
-    groups: ['Logic'],
-    args: [{ name: 'bool', display_name: 'Value', ui_type: 'bool', required: true }],
-  },
-  {
-    name: 'contains',
-    display_name: 'String Contains',
-    short_desc: 'Returns True if the given string contains the given characters',
-    desc: 'Returns `True` if the first argument contains the second.',
-    symbol: 'contains',
-    type: 1,
-    subtype: 1,
-    return_type: 'bool',
-    ui_return_type: 'bool',
-    varargs: false,
-    groups: ['Comparison'],
-    render_template: '$arg[0] contains $arg[1]${arg[2] ? (ignore case):}',
-    args: stringArgs('Substring', 'contains'),
-  },
-  {
-    name: 'starts-with',
-    display_name: 'String Starts With',
-    short_desc: 'Returns True if the given value starts with the given characters',
-    desc: 'Returns `True` if the value starts with the given characters when converted to a string.',
-    symbol: 'startsWith',
-    type: 1,
-    subtype: 1,
-    return_type: 'bool',
-    ui_return_type: 'bool',
-    varargs: false,
-    groups: ['Comparison'],
-    render_template: '$arg[0].startsWith($arg[1], $arg[2])',
-    args: stringArgs('Start String', 'starts with'),
-  },
-  {
-    name: 'ends-with',
-    display_name: 'String Ends With',
-    short_desc: 'Returns True if the given string ends with the given characters',
-    desc: 'Returns `True` if the value ends with the given characters when converted to a string.',
-    symbol: 'endsWith',
-    type: 1,
-    subtype: 1,
-    return_type: 'bool',
-    ui_return_type: 'bool',
-    varargs: false,
-    groups: ['Comparison'],
-    render_template: '$arg[0].endsWith($arg[1], $arg[2])',
-    args: stringArgs('End String', 'ends with'),
-  },
-  // --- Varargs (int) -------------------------------------------------------
-  // The base of the variable-arguments family. `varargs: true` + `subtype: 1`
-  // (NOT 2 — subtype 2 is the &&/|| logical-group path) so `addMissingArgs`
-  // appends `min_args - 1` plain int slots. `min_args: 1` matches the IDE `+`.
-  {
-    name: '+',
-    display_name: 'Addition',
-    short_desc: 'Returns the sum of all arguments',
-    desc: 'Returns the sum of all arguments. Accepts a variable number of integer operands.',
-    symbol: '+',
-    type: 1,
-    subtype: 1,
-    return_type: 'int',
-    ui_return_type: 'int',
-    varargs: true,
-    min_args: 1,
-    groups: ['Math'],
-    args: [{ name: 'int', display_name: 'Value', ui_type: 'int', required: true }],
-  },
-  // --- Varargs (string) ----------------------------------------------------
-  // String twin of `+` — the reorder stories seed this one because "first",
-  // "second", "third" read as an order where int operands don't.
-  {
-    name: 'concat',
-    display_name: 'Concatenate Strings',
-    short_desc: 'Returns all arguments joined into one string',
-    desc: 'Returns all arguments joined into one string, in argument order. Accepts a variable number of string operands.',
-    symbol: 'concat',
-    type: 2,
-    subtype: 1,
-    return_type: 'string',
-    ui_return_type: 'string',
-    varargs: true,
-    min_args: 1,
-    groups: ['String'],
-    args: [{ name: 'softstring', display_name: 'Value', ui_type: 'string', required: true }],
-  },
-  // --- Function expressions ------------------------------------------------
-  // Single-arg type-conversion function. Used as the wrap/unwrap base: a
-  // boolean-returning op with one operand ("Value To Convert").
-  {
-    name: 'convert-to-boolean',
-    display_name: 'Convert to Boolean',
-    short_desc: 'Converts the given value to a boolean',
-    desc: 'Converts the given value to a boolean value.',
-    symbol: 'boolean',
-    type: 1,
-    subtype: 1,
-    return_type: 'bool',
-    ui_return_type: 'bool',
-    varargs: false,
-    groups: ['Conversion'],
-    // `ui_type: 'richtext'` (not `any`): a concrete operand type so the operand
-    // field renders once it carries a value. String/richtext input is a
-    // faithful conversion source.
-    args: [
-      { name: 'softstring', display_name: 'Value To Convert', ui_type: 'richtext', required: true },
-    ],
-  },
-  // List → string join. The wrap target: a single-operand op ("List To Join")
-  // an expression can be wrapped in.
-  {
-    name: 'join-list',
-    display_name: 'Join List Elements',
-    short_desc: 'Joins the elements of a list into a single string',
-    desc: 'Joins the elements of the given list into a single string.',
-    symbol: 'join',
-    type: 1,
-    subtype: 1,
-    return_type: 'string',
-    ui_return_type: 'string',
-    varargs: false,
-    groups: ['List'],
-    args: [{ name: 'list', display_name: 'List To Join', ui_type: 'list', required: true }],
-  },
-  // String op whose first operand is `richtext` (types_accepted: ['any']),
-  // so a `date`-typed first arg is accepted-but-not-exact when an op switches
-  // to it — this drives the mismatched-types confirmation modal (Tier B).
-  // The third arg mirrors the live op's "Regex Options" — a list with
-  // `element_allowed_values` — for the IDE's `WithArgWithAllowedValues` /
-  // `ArgsChangeWhenOperatorChanges` story family.
-  {
-    name: 'regex',
-    display_name: 'Matches Regular Expression',
-    short_desc: 'Returns True if the given value matches the regular expression',
-    desc: 'Returns `True` if the value matches the given regular expression.',
-    symbol: 'regex',
-    type: 1,
-    subtype: 1,
-    return_type: 'bool',
-    ui_return_type: 'bool',
-    varargs: false,
-    groups: ['Comparison'],
-    render_template: '$arg[0] =~ /$arg[1]/$arg[2]',
-    args: [
-      { name: 'softstring', display_name: 'String Value', ui_type: 'richtext', required: true },
-      { name: 'string', display_name: 'Regular Expression', ui_type: 'string', required: true },
-      {
-        name: 'list',
-        display_name: 'Regex Options',
-        ui_type: 'list',
-        required: false,
-        element_allowed_values: [
-          {
-            display_name: 'Global',
-            short_desc: 'Match all occurrences',
-            value: { value: 'g', type: 'string' },
-          },
-          {
-            display_name: 'Multiline',
-            short_desc: '^ and $ match line boundaries',
-            value: { value: 'm', type: 'string' },
-          },
-          {
-            display_name: 'Case Insensitive',
-            short_desc: 'Ignore case when matching',
-            value: { value: 'i', type: 'string' },
-          },
-        ],
-      },
-    ],
-  },
-  // Date formatter — first operand `date`, second `richtext`. The mismatch
-  // base: switching this to a string op (`regex`) makes the `date` first arg
-  // accepted-but-not-exact → the confirmation modal.
-  {
-    name: 'format_date',
-    display_name: 'Format Date',
-    short_desc: 'Formats a date according to the given format string',
-    desc: 'Formats the given date value according to the given format string.',
-    symbol: 'format_date',
-    type: 2,
-    subtype: 1,
-    return_type: 'string',
-    ui_return_type: 'string',
-    varargs: false,
-    groups: ['Date'],
-    args: [
-      { name: 'date', display_name: 'Date To Format', ui_type: 'date', required: true },
-      { name: 'string', display_name: 'Format String', ui_type: 'richtext', required: true },
-    ],
-  },
-  // Number formatter — first operand `int`/`number`. The IDE's
-  // `FunctionFirstArgTypeCanBeChanged` target.
-  {
-    name: 'format_number',
-    display_name: 'Format Number',
-    short_desc: 'Formats a number according to the given format string',
-    desc: 'Formats the given number value according to the given format string.',
-    symbol: 'format_number',
-    type: 2,
-    subtype: 1,
-    return_type: 'string',
-    ui_return_type: 'string',
-    varargs: false,
-    groups: ['Number'],
-    args: [
-      { name: 'number', display_name: 'Number To Format', ui_type: 'number', required: true },
-      { name: 'string', display_name: 'Format String', ui_type: 'richtext', required: true },
-    ],
-  },
-];

package/src/components/form/expressions/renderExpressionToText.ts

@@ -1,137 +0,0 @@
-// Copyright 2026 Qore Technologies, s.r.o.
-// Client-side expression renderer — an approximation of an expression AST for
-// the read-first row summaries, which must render synchronously. Nothing that
-// can wait uses it: Explain and the Text view's Preview wait for the server's
-// `dpql/renderExpression` (see `useRenderExpression`). Pure: no
-// transport/socket import, so it stays out of the LSP/nanoid dependency graph.
-import { IExpression, IExpressionSchema, IExpressionValue } from './types';
-
-/** A symbol made only of non-word characters renders infix (`a == b`). */
-const isOperatorSymbol = (symbol?: string): boolean =>
-  !!symbol && /^[^\w\s]+$/.test(symbol);
-
-/**
- * Operator precedence, lower binds tighter.
- *
- * Mirrors `DpqlOperatorPrecedence` in the Qore DataProvider module, which is
- * the source of truth — the server renders the same ASTs through
- * `DataProvider::renderExpression`, and a row summary that parenthesised
- * differently would make the same expression read two ways depending on
- * whether it was collapsed or open. (It does not model the catalogue's
- * `render_template`s, so `contains` still reads as a call here.)
- */
-const PRECEDENCE: Record<string, number> = {
-  '*': 1,
-  '/': 1,
-  '%': 1,
-  '+': 2,
-  '-': 2,
-  '!': 3,
-  '==': 4,
-  '!=': 4,
-  '<': 4,
-  '<=': 4,
-  '>': 4,
-  '>=': 4,
-  '&&': 5,
-  '||': 6,
-};
-
-/** Anything that is not an operator; nothing binds tighter. */
-const PREC_PRIMARY = 0;
-/** Looser than every operator, so a value rendered in it is never wrapped. */
-const PREC_LOOSEST = 7;
-
-/**
- * Operators whose grouping cannot change the result.
- *
- * `+` is deliberately absent: it concatenates when an operand is a string, so
- * `1 + (2 + "a")` is `"12a"` where `1 + 2 + "a"` is `"3a"`. Dropping its
- * parentheses would not be a cosmetic simplification.
- */
-const ASSOCIATIVE = new Set(['&&', '||']);
-
-const precedenceOf = (exp?: string): number => PRECEDENCE[exp ?? ''] ?? PREC_PRIMARY;
-
-/**
- * The context an operator's argument is rendered in — the same rule as
- * `DpqlSerializer::getArgumentContext()`.
- *
- * The first argument is where left-associative parsing puts a same-precedence
- * child back, so it needs no parentheses; a later one does, or `1 - (2 - 3)`
- * reads as `1 - 2 - 3`, which is a different expression.
- */
-const argumentContext = (exp: string, argn: number): number => {
-  const prec = precedenceOf(exp);
-  return !argn || ASSOCIATIVE.has(exp) ? prec : prec - 1;
-};
-
-/** An argument reaches this as a bare value or as a `{type, value}` envelope. */
-const readArgValue = (arg: unknown): unknown =>
-  arg !== null && typeof arg === 'object' && 'value' in (arg as object)
-    ? (arg as { value: unknown }).value
-    : arg;
-
-const renderLiteral = (value: unknown): string => {
-  if (value === undefined || value === null) return 'null';
-  if (typeof value === 'string') return JSON.stringify(value);
-  if (typeof value === 'object') return JSON.stringify(value);
-  return String(value);
-};
-
-/** Renders `value` and wraps it only if it binds looser than `contextPrec`. */
-const renderInContext = (
-  value: IExpressionValue | undefined,
-  expressions: IExpressionSchema[],
-  contextPrec: number
-): string => {
-  if (!value?.exp) return '';
-  /* A `value` expression IS its literal.
-  
-     It is the wrapper the parser puts around a bare literal — typing `null`,
-     or `42`, into the text editor produces one — and it carries no symbol, so
-     rendering it through the generic paths printed the wrapper instead of the
-     value: `value(42)` with a catalogue that names it, `(42)` with one that
-     supplies its empty symbol. The server renders the literal alone, and a
-     summary that disagrees with the preview beside it is worse than either. */
-  if (value.exp === 'value' && (value.args ?? []).length === 1) {
-    const only = (value.args ?? [])[0] as IExpression;
-    if (!only?.is_expression) {
-      return renderLiteral(readArgValue(only));
-    }
-  }
-  const schema = expressions.find((e) => e.name === value.exp);
-  const symbol = schema?.symbol ?? value.exp;
-  const args = value.args ?? [];
-  // Logical group (subtype 2) → join with the symbol.
-  const isLogicalGroup = schema?.subtype === 2 || value.exp === '&&' || value.exp === '||';
-  // Binary operator → infix. Everything else renders as a call, whose own
-  // parentheses and commas already delimit its arguments.
-  const isInfix = isLogicalGroup || (args.length === 2 && isOperatorSymbol(symbol));
-
-  const parts = args.map((arg: IExpression, argn: number) =>
-    arg?.is_expression && arg.value?.exp
-      ? renderInContext(
-          arg.value,
-          expressions,
-          isInfix ? argumentContext(value.exp as string, argn) : PREC_LOOSEST
-        )
-      : renderLiteral(arg?.value)
-  );
-
-  if (!isInfix) {
-    return `${symbol}(${parts.join(', ')})`;
-  }
-
-  const text = isLogicalGroup ? parts.join(` ${symbol} `) : `${parts[0]} ${symbol} ${parts[1]}`;
-  return precedenceOf(value.exp) > contextPrec ? `(${text})` : text;
-};
-
-/**
- * Recursively render an expression AST to readable text — the client-side
- * approximation a read-first row summary shows.
- */
-export const renderExpressionToText = (
-  value: IExpressionValue | undefined,
-  expressions: IExpressionSchema[] = []
-): string => renderInContext(value, expressions, PREC_LOOSEST);

package/src/components/form/expressions/types.ts

@@ -1,110 +0,0 @@
-// Copyright 2026 Qore Technologies, s.r.o.
-// Types for the expression subsystem. A Qorus expression is an AST
-// `{ exp, args }`; DPQL is its text serialization (dpql/parse ↔
-// dpql/serialize). A field stores it as `is_expression: true` + the AST.
-import { TQorusExpressionReturnType } from '@qoretechnologies/ts-toolkit';
-
-/** The AST: an expression name plus its argument list. */
-export interface IExpressionValue {
-  exp?: string;
-  args?: IExpression[];
-}
-
-/**
- * One node in an expression. A leaf is `{ type, value }` (a literal or a
- * `$template:ref`); a nested expression sets `is_expression: true` and
- * carries `{ exp, args }` in `value`.
- */
-export interface IExpression {
-  value?: IExpressionValue | any;
-  type?: string;
-  is_expression?: boolean;
-  required?: boolean;
-  /** Set when an arg's value type is accepted-but-not-exact (confirm UI). */
-  types_mismatch?: boolean;
-}
-
-/** The seed value for a fresh expression. */
-export const ExpressionDefaultValue: IExpression = {
-  value: { args: [] },
-  is_expression: true,
-};
-
-/**
- * One argument slot in an expression schema. Mirrors a form-field schema
- * arg plus the operand-label affixes. `ui_type` is the UI type the
- * operand field renders (a superset of `TQorusType` — includes
- * `select-string` etc.), so it is typed loosely as a string.
- */
-export interface IExpressionSchemaArg {
-  name?: string;
-  display_name?: string;
-  short_desc?: string;
-  desc?: string;
-  /** The operand field type (UI superset of TQorusType). */
-  ui_type: string;
-  signature_type_code?: string;
-  required?: boolean;
-  default_value?: any;
-  allowed_values?: any[];
-  element_allowed_values?: any[];
-  /** Text shown before the operand field. */
-  label_before?: string;
-  /** Text shown after the operand field. */
-  label_after?: string;
-  sensitive?: boolean;
-}
-
-/**
- * One entry in the expression catalogue (`GET /system?action=expressions`).
- * `subtype: 2` marks a logical group (`&&` / `||`); `subtype: 1` is a
- * normal expression. `symbol` drives the readable rendering.
- */
-export interface IExpressionSchema {
-  name: string;
-  display_name: string;
-  short_desc: string;
-  desc: string;
-  /**
-   * What the expression evaluates to.
-   *
-   * Not a plain `TQorusType`: the server names a container's element type inline,
-   * so `list<string>` and `hash<auto>` are ordinary answers here and a narrower
-   * type would refuse the catalogue the server actually serves. Taken from
-   * ts-toolkit rather than restated, so the two cannot drift.
-   */
-  return_type: TQorusExpressionReturnType;
-  ui_return_type: string;
-  symbol: string;
-  /**
-   * How the server's readable rendering (`dpql/renderExpression`) spells this
-   * expression, when not by its symbol: `$arg[n]` is an argument, `$symbol` the
-   * symbol, `$args` all arguments, and `${arg[n] ? set : unset}` reads the
-   * argument or its `default_value` — e.g. `$arg[0].startsWith($arg[1], $arg[2])`.
-   */
-  render_template?: string;
-  /** Server type code (operator/function); not a reliable infix discriminator. */
-  type: number;
-  /** `1` normal, `2` logical group (AND/OR). */
-  subtype: 1 | 2;
-  args: IExpressionSchemaArg[];
-  varargs: boolean;
-  role?: number;
-  min_args?: number;
-  groups?: string[];
-  /** Provenance markers when merged with a data-provider's `expressions_url`. */
-  from_server?: boolean;
-  from_both?: boolean;
-  return_type_first_arg?: boolean;
-  return_type_arg_priority?: string[];
-}
-
-/** Where a varargs expression offers operand reordering. */
-export type TExpressionReorderSurface = 'overflowMenu' | 'dragHandle' | 'positionPicker';
-
-/**
- * `true` (the default) renders the drag grip together with the "Move Argument"
- * section in the field's `⋮` menu; `false` turns reordering off; a list
- * renders exactly those surfaces.
- */
-export type TExpressionReorder = boolean | TExpressionReorderSurface[];

package/src/components/form/expressions/useExpressions.ts

@@ -1,101 +0,0 @@
-// Copyright 2026 Qore Technologies, s.r.o.
-// Fetches the expression catalogue (`GET /system?action=expressions`),
-// optionally merged with a data provider's per-action `expressions_url`
-// (mirrors qorus-ide's `useExpressions`). The catalogue is static per
-// server version, so the default react-query cache is left on.
-import { useMemo } from 'react';
-import { useFetch } from '../../../hooks/useFetch/useFetch';
-import { IExpressionSchema } from './types';
-
-export interface IUseExpressionsOptions {
-  /** Gate the fetch — when false the hook returns an empty list. */
-  allow?: boolean;
-  /** A data provider's per-action expressions endpoint (extra expressions). */
-  expressionsUrl?: string;
-  /** Inline extra expressions to merge (alternative to `expressionsUrl`). */
-  extraExpressions?: IExpressionSchema[];
-  /** Test seam — return this list directly, no request. */
-  override?: IExpressionSchema[];
-  /** Test seam — report this as a fetch failure, no request. */
-  errorOverride?: unknown;
-}
-
-export interface IUseExpressionsResult {
-  expressions: IExpressionSchema[];
-  loading: boolean;
-  error?: unknown;
-  reload: () => void;
-}
-
-/** Unwrap `{ data: [...] }` or a bare `[...]` into the array. */
-const asArray = (value: unknown): IExpressionSchema[] => {
-  if (Array.isArray(value)) return value as IExpressionSchema[];
-  const data = (value as { data?: unknown })?.data;
-  return Array.isArray(data) ? (data as IExpressionSchema[]) : [];
-};
-
-/**
- * Unique-merge system + extra expressions, marking shared ones `from_both`
- * and extra-only ones `from_server` (qorus-ide's marking convention).
- */
-const mergeExpressions = (
-  base: IExpressionSchema[],
-  extra: IExpressionSchema[]
-): IExpressionSchema[] => {
-  if (!extra.length) return base;
-  const merged: IExpressionSchema[] = base.map((expr) =>
-    extra.some((e) => e.name === expr.name) ? { ...expr, from_both: true } : expr
-  );
-  extra.forEach((e) => {
-    if (!base.some((expr) => expr.name === e.name)) {
-      merged.push({ ...e, from_server: true });
-    }
-  });
-  return merged;
-};
-
-export const useExpressions = (
-  options: IUseExpressionsOptions = {}
-): IUseExpressionsResult => {
-  const { allow = true, expressionsUrl, extraExpressions, override, errorOverride } = options;
-  const shouldFetch = allow && !override && !errorOverride;
-
-  const system = useFetch<IExpressionSchema[]>({
-    url: 'system?action=expressions&context=ui',
-    method: 'GET',
-    loadOnMount: shouldFetch,
-  });
-
-  const extra = useFetch<IExpressionSchema[] | { data: IExpressionSchema[] }>({
-    url: expressionsUrl ?? '',
-    method: 'GET',
-    loadOnMount: shouldFetch && !!expressionsUrl,
-    // The provider URL is often absolute; skip the `api/latest/` prefix then.
-    noApiPrefix: !!expressionsUrl && /^https?:\/\//.test(expressionsUrl),
-  });
-
-  const expressions = useMemo<IExpressionSchema[]>(() => {
-    if (errorOverride) return [];
-    if (override) return override;
-    // Through `asArray` like the extras: an answer that is not a list (the
-    // instance-info hash, when something answers `system` for
-    // `system?action=expressions`) leaves the catalogue empty instead of
-    // throwing inside every form below.
-    const base = asArray(system.data);
-    const extras = expressionsUrl ? asArray(extra.data) : extraExpressions ?? [];
-    return mergeExpressions(base, extras);
-  }, [override, errorOverride, system.data, extra.data, expressionsUrl, extraExpressions]);
-
-  return {
-    expressions,
-    // `extra` is deliberately not loaded without an expressions URL.  The
-    // generic fetch hook keeps an unstarted request in its initial loading
-    // state, so only include it when that request is actually enabled.
-    loading: system.loading || (!!expressionsUrl && extra.loading),
-    error: errorOverride ?? system.error ?? extra.error,
-    reload: () => {
-      system.load();
-      if (expressionsUrl) extra.load();
-    },
-  };
-};