@qoretechnologies/reqraft 0.10.62 → 0.10.63-pr.142.g0b675cd

package/src/helpers/common.ts

@@ -1,326 +0,0 @@
-import { IReqoreRichTextEditorProps } from '@qoretechnologies/reqore/dist/components/RichTextEditor';
-import { TQorusFormFieldSchema, TQorusFormOperatorValue } from '@qoretechnologies/ts-toolkit';
-import yaml from 'js-yaml';
-
-// ─── Typed ↔ YAML helpers ──────────────────────────────────────────────────────
-
-type TTypedValue = { type: string; value: unknown };
-type MaybeTyped = TTypedValue | undefined;
-
-const inferTypedValue = (raw: unknown): MaybeTyped => {
-  if (raw === null || raw === undefined) return undefined;
-  if (typeof raw === 'boolean') return { type: 'bool', value: raw };
-  if (typeof raw === 'number')
-    return Number.isInteger(raw) ? { type: 'int', value: raw } : { type: 'float', value: raw };
-  if (typeof raw === 'string') return { type: 'string', value: raw };
-  if (Array.isArray(raw)) {
-    const items = raw.map(inferTypedValue).filter(Boolean);
-    return { type: 'list', value: items };
-  }
-  if (typeof raw === 'object') {
-    const value = Object.fromEntries(
-      Object.entries(raw as Record<string, unknown>).map(([k, v]) => [k, inferTypedValue(v)])
-    );
-    return { type: 'hash', value };
-  }
-  return { type: 'any', value: raw };
-};
-
-const typedToPlain = (typed: MaybeTyped): unknown => {
-  if (typed === undefined || typed === null) return undefined;
-  // A raw primitive (string/number/bool) is already plain — e.g. a `list` whose
-  // items are bare values rather than `{ type, value }` wrappers. Destructuring it
-  // would lose the value (it became `null` items in the YAML editor).
-  if (typeof typed !== 'object') return typed;
-  const { type, value } = typed as { type?: string; value?: unknown };
-  if (type === 'list') {
-    // Guard the `.map`: a malformed/non-array list value (e.g. a string from a
-    // YAML round-trip) must not crash the editor — render it as-is instead.
-    return Array.isArray(value) ? value.map(typedToPlain) : value;
-  }
-  if (type === 'hash') {
-    return value && typeof value === 'object' && !Array.isArray(value) ?
-        Object.fromEntries(
-          Object.entries(value as Record<string, MaybeTyped>).map(([k, v]) => [k, typedToPlain(v)])
-        )
-      : value;
-  }
-  // An object with no recognised `type` wrapper is already plain data.
-  if (type === undefined) return typed;
-  return value;
-};
-
-export const yamlToTyped = (yamlString: string): MaybeTyped => {
-  try {
-    const raw = yaml.load(yamlString) as unknown;
-    return inferTypedValue(raw);
-  } catch {
-    return { type: 'string', value: yamlString };
-  }
-};
-
-export const typedToYaml = (typed: MaybeTyped): string => {
-  if (typeof typed === 'undefined') return '';
-  const plain = typedToPlain(typed);
-  try {
-    return yaml.dump(plain, { skipInvalid: true });
-  } catch {
-    return '';
-  }
-};
-
-export const getDefaultValue = (schema?: TQorusFormFieldSchema): unknown | undefined => {
-  // No schema, no default. A form can hold a value key its schema does not
-  // (yet) describe — a host that recomputes schema and value in separate
-  // memos renders once in between — and the compact row asks for the default
-  // of every empty row. `'default_value' in undefined` is a TypeError that
-  // takes the whole form to the error boundary; the answer is simply "none".
-  if (!schema) {
-    return undefined;
-  }
-  if ('default_value' in schema) {
-    const value: unknown = schema.default_value;
-    // The server sends a default either bare, of any type — a list or a hash
-    // included — or in a `{ type, value }` envelope; only the envelope is
-    // unwrapped.
-    if (value != null && typeof value === 'object' && !Array.isArray(value) && 'type' in value) {
-      return (value as { value?: unknown }).value;
-    }
-
-    return value;
-  }
-
-  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
-  // it) — only a real Slate document is an array of nodes.
-  if (!Array.isArray(richtext)) {
-    return richtext === undefined || richtext === null ? '' : String(richtext);
-  }
-
-  const processElement = (element: any | { text: string }): string => {
-    if (element === null || element === undefined) {
-      return '';
-    }
-
-    if (typeof element !== 'object') {
-      return String(element);
-    }
-
-    if ('text' in element) {
-      return element.text;
-    }
-
-    if (element.type === 'tag') {
-      return element.value?.toString() || '';
-    }
-
-    return Array.isArray(element.children) ? element.children.map(processElement).join('') : '';
-  };
-
-  return richtext.map(processElement).join('');
-};
-
-/** One piece of a richtext document, flattened to a single line: a run of
- * plain prose (`text`) or an embedded template tag (`tag`). Used by the
- * read-first row to render tags as `$`-chips instead of raw `$prefix:name`. */
-export interface IRichtextSegment {
-  kind: 'text' | 'tag';
-  /** Prose for `text`; the tag's display label (or its value) for `tag`. */
-  text: string;
-  /** The raw template value for `tag` (e.g. `$local:some-richtext`). */
-  value?: string;
-}
-
-/** Like {@link richtextToString}, but keeps embedded template tags as discrete
- * segments (adjacent prose is coalesced) so a caller can render the tags as
- * chips. A non-document scalar collapses to a single text segment. */
-export const richtextToSegments = (
-  richtext: IReqoreRichTextEditorProps['value']
-): IRichtextSegment[] => {
-  if (!Array.isArray(richtext)) {
-    const text = richtext === undefined || richtext === null ? '' : String(richtext);
-    return text ? [{ kind: 'text', text }] : [];
-  }
-
-  const segments: IRichtextSegment[] = [];
-  const pushText = (text: string): void => {
-    if (!text) return;
-    const last = segments[segments.length - 1];
-    if (last?.kind === 'text') last.text += text;
-    else segments.push({ kind: 'text', text });
-  };
-
-  const walk = (element: any): void => {
-    if (element === null || element === undefined) return;
-    if (typeof element !== 'object') {
-      pushText(String(element));
-      return;
-    }
-    if ('text' in element) {
-      pushText(element.text);
-      return;
-    }
-    if (element.type === 'tag') {
-      const value = element.value?.toString() || '';
-      segments.push({ kind: 'tag', value, text: (element.label ?? value)?.toString() || value });
-      return;
-    }
-    if (Array.isArray(element.children)) element.children.forEach(walk);
-  };
-
-  richtext.forEach(walk);
-  return segments;
-};
-
-/**
- * An operator value as the list it logically is.
- *
- * An option's `op` holds either one operator or a chain of them, and both
- * spellings are legitimate on the wire. Every reader wants the list.
- */
-export const fixOperatorValue = (
-  operator: TQorusFormOperatorValue
-): (string | null | undefined)[] => (Array.isArray(operator) ? operator : [operator]);
-
-export const insertAtIndex = (array: any[] = [], index = 0, value: any): any[] => {
-  return [...array.slice(0, index), value, ...array.slice(index)];
-};
-
-/** Splits a byte-size string (e.g. `"10MiB"`) into `[amount, unit]`. */
-export const splitByteSize = (value?: string): [number | undefined, string | undefined] => {
-  const amount = String(value ?? '').match(/\d+/g);
-  const unit = String(value ?? '').match(/[a-zA-Z]+/g);
-  return [amount?.[0] ? Number(amount[0]) : undefined, unit?.[0]];
-};
-
-export type TTimeoutUnit = 'ms' | 'seconds' | 'minutes' | 'hours';
-
-/** Timeout display units, smallest → largest, with the ms multiplier each one
- * scales by and the symbol shown where space is tight (phone-width selector).
- * The stored value is always the integer millisecond count. */
-export const TIMEOUT_UNITS: { value: TTimeoutUnit; ms: number; short: string }[] = [
-  { value: 'ms', ms: 1, short: 'ms' },
-  { value: 'seconds', ms: 1000, short: 's' },
-  { value: 'minutes', ms: 60000, short: 'm' },
-  { value: 'hours', ms: 3600000, short: 'h' },
-];
-
-export const timeoutUnitToMs = (unit: TTimeoutUnit): number =>
-  TIMEOUT_UNITS.find(({ value }) => value === unit)!.ms;
-
-export const timeoutUnitSymbol = (unit: TTimeoutUnit): string =>
-  TIMEOUT_UNITS.find(({ value }) => value === unit)!.short;
-
-/** The largest unit that represents `value` without rounding (45000 →
- * seconds, 90500 → ms). Zero divides evenly by everything, so it stays ms. */
-export const getLargestExactTimeoutUnit = (value?: number): TTimeoutUnit => {
-  for (let i = TIMEOUT_UNITS.length - 1; i >= 0; i--) {
-    if (value != null && value !== 0 && value % TIMEOUT_UNITS[i].ms === 0) {
-      return TIMEOUT_UNITS[i].value;
-    }
-  }
-  return 'ms';
-};
-
-/** Human-readable timeout (e.g. `"45 seconds"`) — scaled to the largest unit
- * that represents the millisecond count exactly (90500 → `"90500 ms"`). */
-export const formatTimeoutValue = (ms: number): string => {
-  const unit = getLargestExactTimeoutUnit(ms);
-  return `${ms / timeoutUnitToMs(unit)} ${unit}`;
-};
-
-/** Human-readable file size, e.g. `"12.3 KB"` — whole bytes below 1 KiB, one
- *  decimal above. Shared by the ticket thread / references attachment rows. */
-export const formatBytes = (bytes: number): string => {
-  if (bytes < 1024) {
-    return `${bytes} B`;
-  }
-  const units = ['KB', 'MB', 'GB'];
-  let value = bytes / 1024;
-  let unit = 0;
-  while (value >= 1024 && unit < units.length - 1) {
-    value /= 1024;
-    unit += 1;
-  }
-  return `${value.toFixed(1)} ${units[unit]}`;
-};
-
-/** True when a MIME content type is an image (`image/*`). */
-export const isImage = (contentType: string): boolean => contentType.startsWith('image/');
-
-// URL value splitting (IDE `urlField.tsx` behavior). Lives here rather than
-// in the Url component so `validations.ts` can use it without pulling the
-// component chain into non-DOM consumers (jest).
-export const getProtocol = (v?: string): string => {
-  const valueList = v?.split('://');
-
-  if (!valueList || valueList.length <= 1) {
-    return '';
-  }
-
-  return valueList[0];
-};
-
-export const getAddress = (v?: string): string => {
-  const valueList = v?.split('://');
-
-  if (!valueList || valueList.length === 0) {
-    return '';
-  }
-
-  if (valueList.length === 1) {
-    return valueList[0];
-  }
-
-  // We need to join back the rest of the address in case there were :// in it
-  return valueList.slice(1).join('://');
-};
-
-// ─── List helpers ─────────────────────────────────────────────────────────────
-
-/** Immutably moves a list element from `from` to `to`. */
-export const moveItem = <T>(list: T[], from: number, to: number): T[] => {
-  if (from === to || from < 0 || to < 0 || from >= list.length) return list;
-  const next = [...list];
-  const [item] = next.splice(from, 1);
-  next.splice(Math.min(to, next.length), 0, item);
-  return next;
-};
-
-/** `1` → `1st`, `2` → `2nd`, `11` → `11th`. */
-export const ordinal = (n: number): string => {
-  const mod100 = n % 100;
-
-  if (mod100 >= 11 && mod100 <= 13) {
-    return `${n}th`;
-  }
-
-  switch (n % 10) {
-    case 1:
-      return `${n}st`;
-    case 2:
-      return `${n}nd`;
-    case 3:
-      return `${n}rd`;
-    default:
-      return `${n}th`;
-  }
-};

package/src/helpers/dpqlDetection.ts

@@ -1,209 +0,0 @@
-// Copyright 2026 Qore Technologies, s.r.o.
-/**
- * Noticing that text typed into a PLAIN (non-expression) field is really a
- * DPQL expression, and deciding what to do about it.
- *
- * The rule this implements, in one sentence: **switch the field into
- * expression mode only when the text cannot be a valid literal for the
- * field's type but IS a real expression; otherwise offer, never silently
- * reinterpret.** Quietly turning the string `a + b` into a concatenation on a
- * `string` field would destroy a legitimate literal, so a type that accepts
- * any text never auto-switches — it only ever offers.
- *
- * ## Why the server has the last word
- *
- * "Does this parse as DPQL?" is NOT a usable test, which is the trap here.
- * Verified against the live LSP: `dpql/parse` reports `success: true` for
- * `hello`, for `42`, for `2026-09-06` and for `@a` — it wraps each of them in
- * a trivial `{exp: 'value', args: [...]}` node. Everything is a valid DPQL
- * program, because a bare literal is one. So a text that parses tells us
- * nothing; what tells us something is the SHAPE of the AST that comes back:
- *
- * | typed text        | `exp`      | verdict    |
- * |-------------------|------------|------------|
- * | `hello`, `42`     | `value`    | a literal  |
- * | `$local:count`    | `template` | a template |
- * | `@a > 5`          | `>`        | expression |
- * | `"a" + "b"`       | `+`        | expression |
- * | `toInt("5")`      | `toInt`    | expression |
- *
- * `isRealExpressionAst` is that test, and it is the only authority. The
- * lexical pass below decides nothing — its sole job is to keep a server
- * round-trip off every keystroke of every field.
- */
-import { validateField } from './validations';
-
-/** What to do about text that turned out to be an expression. */
-export type TDpqlDetectionOutcome =
-  /** Not an expression, or not one we may act on — leave the field alone. */
-  | 'none'
-  /** A real expression, but the text is also a valid literal here: ask. */
-  | 'offer'
-  /** A real expression, and the text cannot be a literal here: switch. */
-  | 'switch';
-
-/**
- * The `exp` values that mean "this is not an expression": a bare literal and
- * a bare template reference. A template is already the template field's job
- * (`isValueTemplate`), and a literal is what the plain field is for.
- */
-const NON_EXPRESSION_OPS = new Set(['value', 'template']);
-
-/**
- * Operators and calls whose presence makes a server probe worth the trip.
- * Deliberately generous — a false positive costs one debounced request that
- * comes back `exp: 'value'`, while a false negative silently loses the whole
- * feature.
- *
- * ## Why the spacing rules differ per operator
- *
- * `-` and `/` are ambiguous: they appear inside values nobody means as
- * arithmetic — dates (`2026-09-06`), negative numbers (`-5`), paths (`a/b`),
- * hyphenated names (`well-known-name`). A space next to one is what separates
- * `@a - 1` from those, so they keep a spacing requirement.
- *
- * `+` is NOT ambiguous in that way, and requiring spaces around it lost the
- * feature for the most natural way to type arithmetic: `2 + 1` was offered as
- * an expression while `2+1` and `2+ 1` were not, which reads as the detection
- * working only sometimes. Reported from the live IDE. `+` now counts wherever
- * it appears; if the text turns out to be an ordinary literal the server says
- * so and the offer never appears.
- *
- * The `-`/`/` rule is also relaxed from "spaces on BOTH sides" to "a space on
- * either side", so `@a -1` and `@a- 1` are probed too while every ambiguous
- * value above still is not.
- */
-const DPQL_OPERATOR_PATTERN = new RegExp(
-  [
-    '(==|!=|<>|>=|<=)', // two-character comparisons
-    '[<>*%]', // unambiguous single-character operators
-    '(?<!=)=(?!=)', // a lone `=`, not part of `==`
-    '\\+', // `+` — unambiguous, so spacing is irrelevant
-    '(\\s[-/]|[-/]\\s)', // `-` and `/` need a space on at least one side
-    '\\b(and|or|not|like|in|contains)\\b', // word operators
-  ].join('|'),
-  'i'
-);
-
-/** A function call — `toInt("5")`, `upper(@name)`. */
-const DPQL_CALL_PATTERN = /\b[a-z_]\w*\s*\(/i;
-
-/**
- * The longest text worth probing. An expression a person types into a form
- * field is short; anything longer is a document, and probing it on every
- * keystroke would be a waste of a round-trip.
- */
-const MAX_PROBE_LENGTH = 512;
-
-/**
- * Cheap, purely lexical "might this be worth asking the server about?".
- * Never decides anything on its own — see the module comment.
- */
-export const mightBeDpqlExpression = (text: unknown): boolean => {
-  if (typeof text !== 'string') {
-    return false;
-  }
-
-  const trimmed = text.trim();
-
-  if (!trimmed || trimmed.length > MAX_PROBE_LENGTH) {
-    return false;
-  }
-
-  return DPQL_OPERATOR_PATTERN.test(trimmed) || DPQL_CALL_PATTERN.test(trimmed);
-};
-
-/**
- * The authority: does this `dpql/parse` result describe a REAL expression
- * rather than a literal or a bare template reference? Accepts either the
- * field-ready envelope (`{is_expression, value: {exp, args}}`) the server
- * returns or a bare `{exp, args}` node.
- */
-export const isRealExpressionAst = (expression: unknown): boolean => {
-  if (!expression || typeof expression !== 'object') {
-    return false;
-  }
-
-  const envelope = expression as { value?: unknown; exp?: unknown };
-  const node = (
-    envelope.exp === undefined && envelope.value && typeof envelope.value === 'object'
-      ? envelope.value
-      : envelope
-  ) as { exp?: unknown };
-
-  return typeof node.exp === 'string' && !!node.exp && !NON_EXPRESSION_OPS.has(node.exp);
-};
-
-/**
- * `true` when any diagnostic is an outright error. The server reports
- * severity as the string `'error'` on this route and LSP proper uses `1`;
- * both are accepted rather than assuming one.
- */
-export const hasErrorDiagnostic = (
-  diagnostics?: Array<{ severity?: number | string } | undefined | null>
-): boolean =>
-  !!diagnostics?.some((diagnostic) => {
-    const severity = diagnostic?.severity;
-    return severity === 1 || severity === 'error';
-  });
-
-/**
- * Could this text stand as a literal value of the field's own type? A type
- * that accepts any text (`string`, and every type the form validator passes
- * by default) always can, which is exactly why such a field never
- * auto-switches. Delegates to the form's own validator so the answer is the
- * same one the field itself would give.
- */
-export const canBeLiteralOfType = (
-  text: string,
-  type?: string,
-  field?: Record<string, any>
-): boolean => {
-  if (!type) {
-    return true;
-  }
-
-  try {
-    return validateField(type, text, field as any);
-  } catch {
-    // A validator that throws must not be read as "this cannot be a
-    // literal" — that would auto-switch the field on the strength of a bug.
-    return true;
-  }
-};
-
-export interface IClassifyTypedTextArgs {
-  /** The text the author typed into the plain field. */
-  text: string;
-  /** The field's declared type (`ui_type ?? type`). */
-  type?: string;
-  /** The field schema, for validators that consult `validation_regex` etc. */
-  field?: Record<string, any>;
-  /** The `dpql/parse` result for `text`, or `undefined` if it has not run. */
-  parsed?: {
-    success?: boolean;
-    expression?: unknown;
-    diagnostics?: Array<{ severity?: number | string }>;
-  };
-}
-
-/**
- * The whole decision, in one pure function so it can be tested without a
- * server, a socket or a rendered field.
- */
-export const classifyTypedText = ({
-  text,
-  type,
-  field,
-  parsed,
-}: IClassifyTypedTextArgs): TDpqlDetectionOutcome => {
-  if (!parsed?.success || !parsed.expression) {
-    return 'none';
-  }
-
-  if (!isRealExpressionAst(parsed.expression) || hasErrorDiagnostic(parsed.diagnostics)) {
-    return 'none';
-  }
-
-  return canBeLiteralOfType(text, type, field) ? 'offer' : 'switch';
-};

package/src/helpers/expressions.ts

@@ -1,140 +0,0 @@
-// Copyright 2026 Qore Technologies, s.r.o.
-// Expression / type-compatibility helpers — ported verbatim from qorus-ide
-// (`src/helpers/expressions.ts` + `areQorusTypesCompatible` from
-// `src/helpers/functions.tsx`), import paths adapted to reqraft. Used by the
-// ported ExpressionBuilder.
-import { isArray } from 'lodash';
-import {
-  IExpression,
-  IExpressionSchema,
-  IExpressionSchemaArg,
-} from '../components/form/expressions/types';
-import { defaultQorusTypes, getQorusTypes, IQorusTypeObject } from '../hooks/useQorusTypes';
-
-export const getArgumentType = (
-  expressions: IExpressionSchema[],
-  arg?: IExpression,
-  schema?: IExpressionSchemaArg
-) => {
-  if (arg?.is_expression) {
-    return expressions?.find(
-      (exp) => exp.name === (arg.value as { exp?: string })?.exp
-    )?.ui_return_type;
-  }
-
-  return arg?.type || schema?.ui_type;
-};
-
-export const argumentMatchesType = (
-  expressions: IExpressionSchema[],
-  arg: IExpression | undefined,
-  schema: IExpressionSchemaArg
-) => {
-  const types = getQorusTypes();
-  const acceptedTypes = types.find((type) => type.name === schema.ui_type);
-  const argType = getArgumentType(expressions, arg, schema);
-
-  if (!acceptedTypes) {
-    return true;
-  }
-
-  return (
-    argType === 'any' ||
-    !!acceptedTypes.exact_match?.includes(argType as string) ||
-    acceptedTypes.types_accepted.includes('any') ||
-    acceptedTypes.types_accepted.includes(getArgumentType(expressions, arg, schema) as string)
-  );
-};
-
-/**
- * `auto` is the codebase's other spelling of `any` — `Field.tsx` maps both to
- * one renderer, and FormEngine tests `type === 'any' || type === 'auto'` in
- * several places — but the TYPES LIST only carries `any`.
- *
- * That mattered here because an unknown main type falls into the "not found"
- * branch below and answers FALSE for every check. So an `auto`-typed field was
- * judged incompatible with everything: `filterTemplatesByType()` removed every
- * template from it, and the picker offered a group header with nothing under
- * it. The field was not "a field with no templates" — it was a field whose
- * templates had all been filtered away by a name mismatch.
- */
-const normalizeAnyLikeTypeName = (name: string): string => (name === 'auto' ? 'any' : name);
-
-export const areQorusTypesCompatible = (
-  mainType: string | string[],
-  checkType: string | string[],
-  fallbackTypes?: IQorusTypeObject[]
-): boolean => {
-  const types = getQorusTypes() || fallbackTypes || defaultQorusTypes;
-  const mainTypes = (isArray(mainType) ? mainType : [mainType]).map(normalizeAnyLikeTypeName);
-  const checkTypes = (isArray(checkType) ? checkType : [checkType]).map(normalizeAnyLikeTypeName);
-  // Get each of the main types from the types list
-  for (const main of mainTypes) {
-    // Get the type object from the types
-    const mainTypeObject = types.find((type) => type.name === main);
-    // If the main object does not exist
-    if (!mainTypeObject) {
-      return false;
-    }
-    // If the main type includes "any" it's automatically compatible
-    if (mainTypeObject.exact_match?.includes('any')) {
-      return true;
-    }
-    // Check if any of the check types are in the main types accepted types
-    for (const check of checkTypes) {
-      if (mainTypeObject.exact_match?.includes(check)) {
-        return true;
-      }
-    }
-    // If the main type includes "any" it's automatically compatible
-    if (mainTypeObject.types_accepted.includes('any')) {
-      return true;
-    }
-    // Check if any of the check types are in the main types accepted types
-    for (const check of checkTypes) {
-      if (mainTypeObject.types_accepted.includes(check)) {
-        return true;
-      }
-    }
-  }
-  // If none of the types are compatible return false
-  return false;
-};
-
-/**
- * Whether a type is text, a date or a time: what a condition cannot be. A condition is evaluated by its
- * truthiness, so a number (0 or not), a list or hash (empty or not), binary data and an untyped result
- * all decide it; text, dates and times do not say plainly what is meant, and are compared explicitly
- * instead (`@status == "open"`, `@note != ""`). The Qorus server applies the same rule.
- */
-export const isTextOrDateType = (type: string): boolean =>
-  /^(string|richtext|date|time)$/.test(type.replace(/^\*/, '').replace(/^soft/, ''));
-
-/** Whether a place takes a condition: its result must be true or false (`bool`, or a list of only that). */
-export const isConditionType = (returnType: string | string[] | undefined): boolean => {
-  const types = isArray(returnType) ? returnType : returnType ? [returnType] : [];
-  return types.length > 0 && types.every((type) => /^\*?(bool|boolean)$/.test(type));
-};
-
-/**
- * Whether an operation is offered where its result must be of `returnType`: a condition (`bool`) is
- * built from the operations whose result decides it, which is any result but text, a date or a time.
- *
- * 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 => {
-  if (!isConditionType(returnType)) {
-    return true;
-  }
-  const result = expression.ui_return_type;
-  if (expression.return_type_first_arg || !result || result === 'any' || result === 'auto') {
-    return true;
-  }
-  return !isTextOrDateType(result);
-};