@qoretechnologies/reqraft 0.10.44-pr.95.gb67bfb7 → 0.10.44

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

@@ -30,9 +30,11 @@ import { memo, useCallback, useEffect, useMemo, useState } from 'react';
 import { useUpdateEffect } from 'react-use';
 import {
   filterTemplatesByType as templatesFilterFunc,
-  findTemplate,
   getTemplateKey,
   getTemplateValue,
+  isBracedTemplateToken,
+  isCompleteTemplateToken,
+  describeTemplateReference,
   isValueTemplate,
 } from '../../../../helpers/templates';
 import { getTypeFromValue } from '../../../../helpers/validations';
@@ -72,8 +74,17 @@ export const TemplatesListProps: IReqoreDropdownProps = {
 // markup stays verbatim. `type`/`level`/`allowTemplates` are destructured
 // only to keep them off the underlying ReQore component / DOM.
 /* eslint-disable @typescript-eslint/no-unused-vars */
+// `type` is FORWARDED here, unlike the other wrappers below: the long-string
+// field consumes it to decide whether it holds one line (a `string` does, a
+// `long-string`, `hash` or `list` does not) and never spreads it to the DOM.
+// Dropping it made every string field in every FormEngine form a growing
+// textarea, so an alert rule's Internal Name took Enter.
 const LongStringField = ({ name, onChange, type, level, allowTemplates, ...rest }: any) => (
-  <LongStringFormField {...rest} onChange={(value: string) => onChange?.(name, value)} />
+  <LongStringFormField
+    {...rest}
+    type={type}
+    onChange={(value: string) => onChange?.(name, value)}
+  />
 );
 const Number = ({ name, onChange, type, level, allowTemplates, ...rest }: any) => (
   <NumberFormField {...rest} onChange={(value: number | string) => onChange?.(name, value)} />
@@ -216,8 +227,13 @@ export const TemplateDropdownSelector = memo(
     size,
     ...rest
   }: ITemplateDropdownSelectorProps) => {
-    const template = findTemplate(templates, value);
-    const label = template?.label || value || rest.label || 'Select Template';
+    // One resolver for every surface that names a reference — the picker chip
+    // here, the read-only tag, and the compact row's expression summary. The
+    // row and this editor must agree: a reference that reads as its path when
+    // the row is closed cannot read as `$data:{…}` the moment it is opened.
+    const resolved = describeTemplateReference(templates, value);
+    const template = resolved.item;
+    const label = resolved.label || rest.label || 'Select Template';
     const leftIconProps = useMemo(
       (): IReqoreButtonProps['leftIconProps'] => ({
         image: template?.metadata?.image,
@@ -335,8 +351,15 @@ export const TemplateField = memo(
 
     useEffect(() => {
       if (!isTemplate && isValueTemplate(value) && allowTemplates) {
-        // Do not set the template value if the value is a string in auto mode
-        if (type === 'auto' && getTypeFromValue(value) === 'string') {
+        // In auto mode, leave user-typed dollar-strings alone ('$foo: hello'
+        // passes the loose check) — but a string that IS one well-formed token
+        // ($data:{…}, $config:item) must still flip into template mode, or an
+        // arg whose value hydrates after mount is stuck rendering raw text.
+        if (
+          type === 'auto' &&
+          getTypeFromValue(value) === 'string' &&
+          !isCompleteTemplateToken(value)
+        ) {
           return;
         }
 
@@ -359,6 +382,15 @@ export const TemplateField = memo(
 
     const showTemplateToggle = allowCustomValues && allowTemplates && !rest.arg_schema;
 
+    // Only a BRACED context ref (`$data:{…}` — machine-written, nobody types
+    // one) renders as the picker chip (named via `resolveTemplateLabel`)
+    // rather than as its raw text in a string editor. Plain word-path tokens
+    // (`$local:id`) are typeable, so per the build #123 review they keep the
+    // input that offers templates while typing. Mixed text-and-token strings
+    // keep the string editor too; the chip-in-editor treatment arrives with
+    // the rich-text string mode.
+    const templateValueIsBracedToken = isBracedTemplateToken(templateValue);
+
     const templateSupportsCustomValues =
       allowCustomValues && type === 'string' && !hasOnlyAllowedValues;
     const showTemplatesDropdown =
@@ -374,6 +406,11 @@ export const TemplateField = memo(
       showTemplatesDropdown;
 
     const Component = componentFromType ? ComponentMap[type] : Comp;
+    // Only a ComponentMap component gets `type`: it is ours and CONSUMES the
+    // prop (the long-string field needs it to know whether it holds one line)
+    // rather than spreading it onto the DOM. A caller-supplied `Comp` is someone
+    // else's, which is why `type` was kept off this call in the first place.
+    const componentTypeProp = componentFromType ? { type } : {};
     const fieldAriaLabel = rest['aria-label'] ?? label ?? rest.display_name ?? name;
 
     const filteredTemplates = useMemo<IReqoreFormTemplates>(():
@@ -746,13 +783,14 @@ export const TemplateField = memo(
             name={name}
             level={level}
             {...rest}
+            {...componentTypeProp}
             aria-label={fieldAriaLabel}
             className={`${className} template-selector`}
             templates={componentTemplates}
           />
         ) : null}
 
-        {isTemplate && templateSupportsCustomValues ? (
+        {isTemplate && templateSupportsCustomValues && !templateValueIsBracedToken ? (
           <LongStringField
             className='template-selector'
             type='string'
@@ -769,7 +807,8 @@ export const TemplateField = memo(
           />
         ) : null}
 
-        {showTemplatesDropdown ? (
+        {showTemplatesDropdown ||
+        (isTemplate && templateSupportsCustomValues && templateValueIsBracedToken) ? (
           <TemplateDropdownSelector
             allowCustomValues={allowCustomValues}
             templates={templates}

package/src/components/form/fields/template/__fixtures__/longExampleValue.ts

@@ -0,0 +1,7 @@
+/* A deterministic "whole base64 file" example value — the payload class the
+   example-value modal exists for (an email attachment body). No spaces on
+   purpose: the unbroken run is what breaks naive rendering. The sentinel
+   proves a consumer holds the value to the very end. */
+export const LONG_EXAMPLE_VALUE = `${'JVBERi0xLjcKJcTl8uXrp9Og0MTGCjQgMCBvYmoKPDwvRmlsdGVyL0ZsYXRlRGVjb2RlCg=='.repeat(
+  90
+)}THE_VERY_END`;

package/src/components/form/index.tsx

@@ -21,6 +21,7 @@ export * from './fields/rich-text/RichText';
 export * from './fields/select/Select';
 export * from './fields/select/SelectCollection';
 export * from './fields/string/String';
+export * from './fields/template/ExampleValueModal';
 export * from './fields/template/TemplateField';
 export * from './engine/FormEngine';
 export * from './engine/optionActions';

package/src/components/searchFilterBar/SearchFilterBar.stories.tsx

@@ -0,0 +1,62 @@
+import { StoryObj } from '@storybook/react-vite';
+import { expect, fn, within } from 'storybook/test';
+
+import { StoryMeta } from '../../types';
+import { SearchFilterBar } from './SearchFilterBar';
+
+/*
+ * The strip that sits above a list and narrows it: a search box plus the filter
+ * dropdowns that go with it.
+ */
+const meta = {
+  component: SearchFilterBar,
+  title: 'Components/Search Filter Bar',
+  args: {
+    onChange: fn(),
+    placeholder: 'Search tickets…',
+    filters: [
+      {
+        icon: 'Filter3Line' as const,
+        label: 'Any status',
+        items: [
+          { label: 'Any status', value: 'any', selected: true },
+          { label: 'Open', value: 'open' },
+          { label: 'Resolved', value: 'resolved' },
+        ],
+      },
+    ],
+  },
+} as StoryMeta<typeof SearchFilterBar>;
+
+export default meta;
+type Story = StoryObj<typeof meta>;
+
+export const Idle: Story = {
+  args: { value: '' },
+  parameters: {
+    docs: {
+      description: {
+        story: 'Nothing typed — the bar is quiet, and the list below it is the whole list.',
+      },
+    },
+  },
+  play: async ({ canvasElement }) => {
+    expect(within(canvasElement).getByPlaceholderText('Search tickets…')).toBeVisible();
+  },
+};
+
+export const Filtering: Story = {
+  args: { value: 'deploy', intent: 'info' },
+  parameters: {
+    docs: {
+      description: {
+        story:
+          'A query is active, so the box carries `intent="info"`. Without it a filtered list and a genuinely short list look identical, and a reader who lands on three rows cannot tell which they are looking at.',
+      },
+    },
+  },
+  play: async ({ canvasElement }) => {
+    const input = within(canvasElement).getByPlaceholderText('Search tickets…');
+    expect(input).toHaveValue('deploy');
+  },
+};

package/src/components/searchFilterBar/SearchFilterBar.tsx

@@ -1,4 +1,5 @@
 import { ReqoreControlGroup, ReqoreDropdown, ReqoreInput } from '@qoretechnologies/reqore';
+import { TReqoreIntent } from '@qoretechnologies/reqore/dist/constants/theme';
 import { IReqoreIconName } from '@qoretechnologies/reqore/dist/types/icons';
 import styled, { css } from 'styled-components';
 
@@ -70,6 +71,16 @@ export interface ISearchFilterBarProps {
    * panel (the References tab); a bar above a page-level list does not need it.
    */
   sticky?: boolean;
+  /**
+   * Intent for the search box.
+   *
+   * A bar that is narrowing the list should look different from one that is
+   * not — otherwise a reader who arrives at a short list cannot tell whether it
+   * is short or filtered. Callers pass `'info'` while a query is active. Left
+   * to the caller rather than derived from `value`, because a caller may hold
+   * other filter state this component never sees.
+   */
+  intent?: TReqoreIntent;
 }
 
 export const SearchFilterBar = ({
@@ -79,6 +90,7 @@ export const SearchFilterBar = ({
   filters = [],
   stacked,
   sticky,
+  intent,
 }: ISearchFilterBarProps) => (
   <Container $sticky={sticky}>
     {/* `size='small'` on the GROUP, not per control: the bar filters the content, it
@@ -98,6 +110,7 @@ export const SearchFilterBar = ({
         value={value}
         onChange={(event) => onChange((event.currentTarget as HTMLInputElement).value)}
         onClearClick={value ? () => onChange('') : undefined}
+        intent={intent}
         minimal
         fluid
       />

package/src/components/ticketThread/TicketThread.tsx

@@ -198,6 +198,13 @@ const StyledSkeletonThread = styled.div`
   gap: 12px;
   width: 100%;
   min-height: 100%;
+  /* A real message carries its own bubble, so it never touches the host's edge.
+     The skeleton is bare bars, and without this its avatars and lines were
+     pressed flat against the border of whatever holds the thread — which reads
+     as a clipped render rather than as loading. border-box so the padding comes
+     out of the 100% rather than adding to it. */
+  box-sizing: border-box;
+  padding: 12px;
 `;
 
 const StyledSkeletonRow = styled.div<{ $self: boolean }>`

package/src/helpers/common.ts

@@ -1,5 +1,5 @@
 import { IReqoreRichTextEditorProps } from '@qoretechnologies/reqore/dist/components/RichTextEditor';
-import { TQorusFormFieldSchema } from '@qoretechnologies/ts-toolkit';
+import { TQorusFormFieldSchema, TQorusFormOperatorValue } from '@qoretechnologies/ts-toolkit';
 import yaml from 'js-yaml';
 
 // ─── Typed ↔ YAML helpers ──────────────────────────────────────────────────────
@@ -163,6 +163,16 @@ export const richtextToSegments = (
   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)];
 };

package/src/helpers/optionUiTypes.ts

@@ -0,0 +1,153 @@
+/**
+ * The Qorus option `ui_type` vocabulary.
+ *
+ * A `ui_type` names the widget an option is rendered with, and — because the
+ * widget decides what a complete value looks like — it is also what
+ * `validateField` switches on. Both readers have to agree about which strings
+ * are in the vocabulary, so the lists live here rather than beside either one.
+ *
+ * Grouped by what the group means to a reader, not by alphabet: the scalar
+ * types hold a single value, the collection types hold several, the choice
+ * types pick from a supplied set, and the interface types name another Qorus
+ * object by its name — which is why `isOptionInterfaceUiType` is enough for
+ * validation to treat the whole group as a non-empty string.
+ */
+
+export const OPTION_SCALAR_UI_TYPES = [
+  'string',
+  'long-string',
+  'data',
+  'binary',
+  'richtext',
+  'bool',
+  'boolean',
+  'date',
+  'int',
+  'integer',
+  'float',
+  'number',
+  'byte-size',
+  'url',
+  'code-editor',
+  'rgbcolor',
+  'any',
+  'auto',
+  // semantic string formats (string-backed types that carry a UI-renderable identity; see the qore
+  // DataProvider QoreStringFormatDataType)
+  'email',
+  'uri',
+  'uuid',
+  'hostname',
+  'ipv4',
+  'ipv6',
+  'phone',
+] as const;
+
+export const OPTION_COLLECTION_UI_TYPES = [
+  'hash',
+  'free-hash',
+  'list',
+  'free-list',
+  'option_hash',
+  'file',
+  'file-as-string',
+  'collection-documents',
+] as const;
+
+export const OPTION_CHOICE_UI_TYPES = [
+  'enum',
+  'select-string',
+  'select-array',
+  'multi-select',
+] as const;
+
+export const OPTION_INTERFACE_UI_TYPES = [
+  'workflow',
+  'service',
+  'job',
+  'connection',
+  'mapper',
+  'class',
+  'value-map',
+  'fsm',
+  'qog',
+  'api-schema',
+  'auth-profile',
+  'ai-collection',
+  'ai-endpoint',
+  'ai-guardrail',
+  'ml-model',
+  'release-config',
+  'alertrule',
+  'alertsilence',
+  'installed-release',
+  'business-process',
+  'schema',
+  'test',
+] as const;
+
+export const OPTION_CUSTOM_UI_TYPES = [
+  'processor',
+  'processor-mappings',
+  'data-provider',
+  'tool-catalog',
+  'schema-definition',
+  'test-cases',
+  'test-value-contract',
+  'dpql',
+  'active-windows',
+] as const;
+
+export const OPTION_UI_TYPES = [
+  ...OPTION_SCALAR_UI_TYPES,
+  ...OPTION_COLLECTION_UI_TYPES,
+  ...OPTION_CHOICE_UI_TYPES,
+  ...OPTION_INTERFACE_UI_TYPES,
+  ...OPTION_CUSTOM_UI_TYPES,
+] as const;
+
+export type TOptionUiType = (typeof OPTION_UI_TYPES)[number];
+export type TOptionInterfaceUiType = (typeof OPTION_INTERFACE_UI_TYPES)[number];
+
+export const LEGACY_FIELD_UI_TYPES = [
+  'api-manager',
+  'array',
+  'array-auto',
+  'array-of-pairs',
+  'class-array',
+  'class-connectors',
+  'constant-array',
+  'context-selector',
+  'cron',
+  'data-provider-options',
+  'file-array',
+  'fsm-list',
+  'function-array',
+  'http-content',
+  'method-name',
+  'opcua-method-arguments',
+  'opcua-write-values',
+  'options',
+  'select',
+  'service-events',
+  'service-webhooks',
+  'type-selector',
+] as const;
+
+export const KNOWN_QORUS_UI_TYPES = [...OPTION_UI_TYPES, ...LEGACY_FIELD_UI_TYPES] as const;
+
+export type TLegacyFieldUiType = (typeof LEGACY_FIELD_UI_TYPES)[number];
+export type TKnownQorusUiType = (typeof KNOWN_QORUS_UI_TYPES)[number];
+
+const optionUiTypeSet = new Set<string>(OPTION_UI_TYPES);
+const interfaceUiTypeSet = new Set<string>(OPTION_INTERFACE_UI_TYPES);
+const knownQorusUiTypeSet = new Set<string>(KNOWN_QORUS_UI_TYPES);
+
+export const isOptionUiType = (type: unknown): type is TOptionUiType =>
+  typeof type === 'string' && optionUiTypeSet.has(type);
+
+export const isOptionInterfaceUiType = (type: unknown): type is TOptionInterfaceUiType =>
+  typeof type === 'string' && interfaceUiTypeSet.has(type);
+
+export const isKnownQorusUiType = (type: unknown): type is TKnownQorusUiType =>
+  typeof type === 'string' && knownQorusUiTypeSet.has(type);

package/src/helpers/options.ts

@@ -29,3 +29,26 @@ export const getRequiredOptionMessage = (
 
   return `This field or ${requiredOptions} is required`;
 };
+
+/**
+ * The value of one element of a list field.
+ *
+ * A list element arrives in either of two shapes, and both are legitimate. The
+ * editor keeps each element in a `{value, type}` envelope while the form is
+ * being worked on — that is what `formatToServerValue` writes — while a value
+ * read back from storage holds what the server contract asks for, which for a
+ * list of strings is the bare strings.
+ *
+ * Reaching straight for `.value` answered `undefined` for every stored element.
+ * On a read that emptied the row; on a validation pass it failed the element as
+ * empty; and on an autosaving form the emptiness was then written back over the
+ * stored value. One helper so the readers cannot disagree about which shape
+ * they are looking at.
+ *
+ * An array is never an envelope — a rich-text document is itself an array, and
+ * `'value' in []` is false anyway, but saying so keeps the intent legible.
+ */
+export const getListElementValue = (element: unknown): unknown =>
+  element && typeof element === 'object' && !Array.isArray(element) && 'value' in element ?
+    (element as { value: unknown }).value
+  : element;

package/src/helpers/providerValue.ts

@@ -0,0 +1,125 @@
+import { TQorusForm } from '@qoretechnologies/ts-toolkit';
+
+export type TRecordType = 'search' | 'search-single' | 'create' | 'update' | 'delete';
+export type TRealRecordType = 'read' | 'create' | 'update' | 'delete';
+
+export type TProviderTypeSupports = {
+  [key in `supports_${TRealRecordType}`]?: boolean;
+};
+
+export type TProviderTypeArgs = {
+  [key in `${TRecordType}_args`]?: TQorusForm | TQorusForm[];
+};
+
+/**
+ * A data-provider selection, in the shape the form holds it.
+ *
+ * The `supports_*` flags say which record operations the selected provider can
+ * perform; validation reads them to decide whether a provider is a legitimate
+ * target for the operation the field was configured for.
+ */
+export interface IProviderType extends TProviderTypeSupports, TProviderTypeArgs {
+  type: string;
+  name: string;
+  path?: string;
+  options?: TQorusForm;
+  subtype?: 'request' | 'response';
+  hasApiContext?: boolean;
+  optionsChanged?: boolean;
+  searchOptionsChanged?: boolean;
+  desc?: string;
+  use_args?: boolean;
+  args?: any;
+  up?: boolean;
+  supports_request?: boolean;
+  supports_messages?: 'ASYNC' | 'SYNC' | 'NONE';
+  supports_observable?: boolean;
+  transaction_management?: boolean;
+  record_requires_search_options?: boolean;
+  create_args_freeform?: TQorusForm[];
+  is_api_call?: boolean;
+  search_options?: TQorusForm;
+  descriptions?: string[];
+  message_id?: string;
+  message?: {
+    type: string;
+    value: any;
+  };
+}
+
+/**
+ * A provider value as an object, from either representation a caller may hold.
+ *
+ * A provider reaches the form either already expanded into `IProviderType`, or
+ * as the flat path string the server stores — `"factory/db{driver=pgsql}/table"`
+ * or the plain `"type/name/path"`. Returns `null` for anything that is neither,
+ * so a caller reports an invalid value rather than reading fields off nothing.
+ */
+export const maybeBuildOptionProvider = (provider: unknown): IProviderType | null => {
+  if (!provider) {
+    return null;
+  }
+  if (typeof provider === 'object') {
+    return provider as IProviderType;
+  }
+  if (typeof provider !== 'string') {
+    return null;
+  }
+
+  if (provider.startsWith('factory')) {
+    const fixedProvider = provider.endsWith('/') ? provider : `${provider}/`;
+    const [factoryType] = fixedProvider.split('/');
+    const factoryName = fixedProvider.substring(
+      fixedProvider.indexOf('/') + 1,
+      fixedProvider.lastIndexOf('{')
+    );
+    const options = fixedProvider.substring(
+      fixedProvider.indexOf('{') + 1,
+      fixedProvider.lastIndexOf('}')
+    );
+    const optionsObject = options
+      .split(',')
+      .filter(Boolean)
+      .reduce<Record<string, string>>((result, option) => {
+        const [key, value] = option.split('=');
+        result[key] = value;
+        return result;
+      }, {});
+    const result: IProviderType = {
+      type: factoryType,
+      name: factoryName,
+      path: fixedProvider.substring(fixedProvider.lastIndexOf('}/') + 2),
+      options: optionsObject as unknown as TQorusForm,
+    };
+    if (provider.includes('?options_changed')) {
+      result.optionsChanged = true;
+    }
+    return result;
+  }
+
+  const [type, name, ...path] = provider.split('/');
+  return { type, name, path: path.join('/') };
+};
+
+/**
+ * An FSM variable action — which variable, and what is done to it.
+ *
+ * The provider half is `Partial<IProviderType>` because the action's own
+ * `action_type` decides which provider fields have to be there; validation
+ * re-runs the matching provider validator over the merged value rather than
+ * duplicating those rules here.
+ */
+export type TVariableActionValue = {
+  var_type: 'globalvar' | 'localvar' | 'autovar';
+  var_name: string;
+  transaction_action?: 'commit' | 'rollback' | 'begin-transaction';
+  action_type?:
+    | 'search'
+    | 'search-single'
+    | 'update'
+    | 'create'
+    | 'delete'
+    | 'transaction'
+    | 'send-message'
+    | 'apicall';
+} & Partial<IProviderType>;

package/src/helpers/singleLineString.ts

@@ -0,0 +1,61 @@
+/**
+ * Which string field types hold one line, and how to keep them that way.
+ *
+ * The server already draws this distinction and the IDE was throwing it away:
+ * a service's `name` is declared `ui_type: "string"` while its `description` is
+ * `ui_type: "long-string"` with `markdown: True` (see `ServiceMetadata.qc`).
+ * Every one of them — plus `email`, `uuid`, `hostname`, `ipv4`, `ipv6` and
+ * `phone` — rendered through the same growing textarea, so a technical name, a
+ * version and an IP address all accepted Enter.
+ *
+ * That is not a cosmetic problem. These values become YAML keys, class names,
+ * URLs and identifiers; a newline in one of them is invalid input that the form
+ * happily accepted and passed on, and the operator had no way to see it.
+ *
+ * The rule is the server's own contract, stated once here rather than guessed
+ * per field, and it is enforced in `LongString.tsx`.
+ *
+ * It lives in reqraft rather than in a consumer because the consumer is not the
+ * only renderer: qorus-ide fixed this in its OWN long-string field, and every
+ * form that goes through FormEngine — which is where an alert rule's Internal
+ * Name, Name and Short Description are — reaches THIS one instead. The fix was
+ * real and the field in front of the operator still took Enter.
+ */
+
+/**
+ * The string types that hold exactly one line — the ones routed to a textarea
+ * today.
+ *
+ * Listed explicitly rather than derived by excluding the document types,
+ * because the two directions fail very differently. Missing a single-line type
+ * here leaves it behaving as it does now — no worse. Wrongly treating a new
+ * DOCUMENT type as single-line would flatten a user's text as they typed it,
+ * which is data loss. So an unrecognised type stays multi-line.
+ */
+const SINGLE_LINE_STRING_TYPES = new Set([
+  'string',
+  'email',
+  'uuid',
+  'hostname',
+  'ipv4',
+  'ipv6',
+  'phone',
+]);
+
+/** True when a string field of this type holds a single line. */
+export const isSingleLineStringType = (type?: string): boolean =>
+  !!type && SINGLE_LINE_STRING_TYPES.has(type);
+
+/**
+ * Flattens any line break to a single space.
+ *
+ * A space rather than nothing, because the newline is usually where a word
+ * boundary was — pasting two lines into a name should read as two words, not
+ * one run-together one. CR, LF and CRLF all collapse to one space, and the
+ * result is trimmed of leading/trailing whitespace the break introduced.
+ */
+export const flattenToSingleLine = (value: string): string =>
+  value.replace(/\r\n|\r|\n/g, ' ').replace(/ {2,}/g, ' ');
+
+/** True when the value carries a line break this field should not hold. */
+export const hasLineBreak = (value: string): boolean => /\r|\n/.test(value);