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

package/src/components/ticketThread/index.ts

@@ -1,6 +0,0 @@
-export { TicketThread, ticketMessageDomId } from './TicketThread';
-export type {
-  ITicketThreadAttachment,
-  ITicketThreadMessage,
-  ITicketThreadProps,
-} from './TicketThread';

package/src/contexts/FetchContext.tsx

@@ -1,25 +0,0 @@
-import { createContext } from 'use-context-selector';
-import { IReqraftFetchResponse, IReqraftQueryConfig } from '../utils/fetch';
-
-export type TReqraftContextQueryConfig = Omit<IReqraftQueryConfig, 'method'>;
-export interface IReqraftFetchContext {
-  get: <T>(config?: TReqraftContextQueryConfig) => Promise<IReqraftFetchResponse<T>>;
-  post: <T>(config?: TReqraftContextQueryConfig) => Promise<IReqraftFetchResponse<T>>;
-  put: <T>(config?: TReqraftContextQueryConfig) => Promise<IReqraftFetchResponse<T>>;
-  del: <T>(config?: TReqraftContextQueryConfig) => Promise<IReqraftFetchResponse<T>>;
-}
-
-export const FetchContext = createContext<IReqraftFetchContext>({
-  get: async () => {
-    throw new Error('FetchContext not implemented');
-  },
-  post: async () => {
-    throw new Error('FetchContext not implemented');
-  },
-  put: async () => {
-    throw new Error('FetchContext not implemented');
-  },
-  del: async () => {
-    throw new Error('FetchContext not implemented');
-  },
-});

package/src/contexts/ReqraftContext.tsx

@@ -1,9 +0,0 @@
-import { createContext } from 'use-context-selector';
-
-export interface IReqraftContext {
-  appName: string;
-}
-
-export const ReqraftContext = createContext<IReqraftContext>({
-  appName: '',
-});

package/src/contexts/StorageContext.tsx

@@ -1,33 +0,0 @@
-import { createContext } from 'react';
-import { Get } from 'type-fest';
-import { TReqraftStorageValue } from '../hooks/useStorage/useStorage';
-
-export type TReqraftStorage = Record<string, any>;
-
-export interface IReqraftStorageContext {
-  storage?: Record<string, any>;
-  getStorage?: <T extends TReqraftStorageValue>(
-    path: string,
-    defaultValue?: T,
-    includeAppPrefix?: boolean
-  ) => Get<TReqraftStorage, string>;
-  updateStorage?: <T extends TReqraftStorageValue>(
-    path: string,
-    value: T,
-    includeAppPrefix?: boolean
-  ) => void;
-  removeStorageValue: (path: string, includeAppPrefix?: boolean) => void;
-}
-
-export const ReqraftStorageContext = createContext<IReqraftStorageContext>({
-  storage: {},
-  getStorage: () => {
-    throw new Error('Storage not implemented');
-  },
-  updateStorage: () => {
-    throw new Error('Storage not implemented');
-  },
-  removeStorageValue: () => {
-    throw new Error('Storage not implemented');
-  },
-});

package/src/global.d.ts

@@ -1,4 +0,0 @@
-declare module '*.png' {
-  const value: string;
-  export = value;
-}

package/src/helpers/allowedValues.ts

@@ -1,268 +0,0 @@
-/**
- * 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 { isRendererOnlyUiType } from '../components/form/engine/rendererTypes';
-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)))
-  );
-};
-
-/**
- * The value a choice stands for, whichever of the three ways its entry is
- * written (see `findAllowedValueOption`): the envelope's `value`, a bare
- * `value`, or the entry's `name`.
- *
- * The row that names a stored choice and the validator that accepts it have
- * always read all three. The pickers that WRITE a choice read only the
- * envelope, so a list written bare showed nothing selected for the stored value
- * and stored `undefined` when a choice was clicked: picking a pipeline
- * processor's class cleared the field instead of setting it.
- */
-export const allowedValueOf = (option: any): unknown => {
-  const value = option?.value;
-  if (value && typeof value === 'object' && !Array.isArray(value) && 'value' in value) {
-    return value.value;
-  }
-  return value !== undefined ? value : option?.name;
-};
-
-/**
- * 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 editor the field is drawn with; see {@link hasOwnEditor}. */
-  ui_type?: string | readonly string[];
-  /**
-   * Set by a form that knows the field is drawn by a bespoke editor of the
-   * consumer's own (one it declared in `rendererOnlyUiTypes`), which reqraft's
-   * built-in list cannot name.
-   */
-  hasOwnEditor?: boolean;
-}
-
-/**
- * Does a bespoke editor, rather than reqraft's choice picker, draw this field?
- *
- * Then the editor alone decides what a value means, and `allowed_values` is not
- * a closed set of values the field may hold. The AI endpoint's Tools field is
- * the case that proved it: its `tool-catalog` editor stores SELECTORS -- `*` for
- * every tool, `system:*`, a connection name, `connection/tool` -- and the host
- * hangs the tool catalogue's SOURCES on `allowed_values` for the editor to
- * browse. Judging the selectors against the sources flagged the server's own
- * default, `["*"]`, as "not one of the choices", so no chat endpoint could be
- * published with it. The server says the same: a custom `ui_type` "defines its
- * own value shape".
- */
-const hasOwnEditor = (field: IChoiceFieldSchema): boolean =>
-  !!field.hasOwnEditor || isRendererOnlyUiType(field.ui_type);
-
-/**
- * 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 field drawn by a bespoke editor (a renderer-only `ui_type` such as
- *   `tool-catalog`), whose values are whatever that editor says they are.
- *
- * 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 ||
-    hasOwnEditor(field)
-  ) {
-    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/choiceChip.ts

@@ -1,227 +0,0 @@
-// Copyright 2026 Qore Technologies, s.r.o.
-import { IQorusAllowedValue, TQorusFormFieldSchema } from '@qoretechnologies/ts-toolkit';
-import { Editor, Node, Path, Range, Transforms } from 'slate';
-import { findAllowedValueOption } from './allowedValues';
-import { getListElementValue } from './options';
-
-/**
- * A value that IS one of the field's own choices, drawn as that choice.
- *
- * A rich-text field offered choices picks one by writing its value, so an
- * author who chose the Slack channel "general" read `C07ERBFS0P6` in the
- * editor. The value is right — it is what the server resolves — but it is not
- * what was chosen by. These helpers draw such a value as one chip named from
- * the choice, the way a template reference is drawn from the catalogue, while
- * what is stored stays the plain value: the chip's own `value` is the choice's,
- * so the text a document stands for is unchanged, and a document that is
- * nothing but the chip is read back as the value it draws.
- */
-
-/** The marker a choice chip carries, so it is told apart from a template reference. */
-export const CHOICE_CHIP_META = 'allowedValue';
-
-export interface IChoiceChipNode {
-  type: 'tag';
-  value: string;
-  label: string;
-  metadata: { [CHOICE_CHIP_META]: true; description?: string };
-  children: [{ text: '' }];
-}
-
-/** The choice's value as the plain string it is; it arrives in the form engine's `{type, value}` envelope. */
-export const choiceValue = (choice: IQorusAllowedValue): string =>
-  String(getListElementValue(choice.value) ?? '');
-
-/**
- * The text a document is, when it is one paragraph of plain text and nothing
- * else; `undefined` for anything more — a chip, a mark, a second paragraph.
- */
-export const plainTextOfNodes = (nodes: unknown): string | undefined => {
-  if (!Array.isArray(nodes) || nodes.length !== 1) {
-    return undefined;
-  }
-
-  const paragraph = nodes[0] as { type?: unknown; children?: unknown[] } | undefined;
-
-  if (paragraph?.type !== 'paragraph' || !Array.isArray(paragraph.children)) {
-    return undefined;
-  }
-
-  let text = '';
-
-  for (const child of paragraph.children as { text?: unknown }[]) {
-    if (typeof child?.text !== 'string' || Object.keys(child).some((key) => key !== 'text')) {
-      return undefined;
-    }
-    text += child.text;
-  }
-
-  return text;
-};
-
-/**
- * The choice a value is: a whole plain string the field offers, or a document
- * that is one paragraph of exactly that text — which is what an edit of the
- * chip stores, so an id typed back is the choice it was. A string or document
- * holding anything more is the author's own text and is never a choice.
- */
-export const choiceForValue = (
-  value: unknown,
-  choices?: IQorusAllowedValue[]
-): IQorusAllowedValue | undefined => {
-  const text = typeof value === 'string' ? value : plainTextOfNodes(value);
-
-  if (!text || !choices?.length) {
-    return undefined;
-  }
-
-  return findAllowedValueOption(text, { allowed_values: choices } as TQorusFormFieldSchema) as
-    | IQorusAllowedValue
-    | undefined;
-};
-
-/** The one-chip document that draws a choice by its name. */
-export const choiceToNodes = (
-  choice: IQorusAllowedValue
-): { type: 'paragraph'; children: ({ text: string } | IChoiceChipNode)[] }[] => {
-  const value = choiceValue(choice);
-  const description = (choice as { desc?: string; short_desc?: string }).short_desc ?? choice.desc;
-
-  return [
-    {
-      type: 'paragraph',
-      children: [
-        { text: '' },
-        {
-          type: 'tag',
-          value,
-          label: choice.display_name ?? value,
-          metadata: { [CHOICE_CHIP_META]: true, ...(description ? { description } : {}) },
-          children: [{ text: '' }],
-        },
-        { text: '' },
-      ],
-    },
-  ];
-};
-
-export const isChoiceChip = (node: unknown): node is IChoiceChipNode =>
-  !!node &&
-  typeof node === 'object' &&
-  (node as { type?: unknown }).type === 'tag' &&
-  !!(node as { metadata?: Record<string, unknown> }).metadata?.[CHOICE_CHIP_META];
-
-/**
- * The value a document is, when the document is one choice chip and nothing
- * else; `undefined` when the author has written anything around it, in which
- * case the document itself is the value.
- */
-export const choiceValueOfNodes = (nodes: unknown): string | undefined => {
-  if (!Array.isArray(nodes) || nodes.length !== 1) {
-    return undefined;
-  }
-
-  const children: unknown[] = (nodes[0] as { children?: unknown[] })?.children ?? [];
-  const chips = children.filter(isChoiceChip);
-  const text = children
-    .filter((node) => !isChoiceChip(node))
-    .map((node) => (typeof (node as { text?: unknown })?.text === 'string' ? (node as { text: string }).text : '\u0000'))
-    .join('');
-
-  return chips.length === 1 && text === '' ? chips[0].value : undefined;
-};
-
-/**
- * What a choice chip does when the author acts on it, by action.
- *
- * The chip is a void: it holds no text of its own, so a key or a click on it
- * has nothing to land in, and an author who wants to change one letter of the
- * value it draws (`C07ERBFS0P6` to `C07ERBFS0P7`) has no way in unless the
- * chip opens. Each action is configurable, and the default is the one that
- * opens it: a creatable choice is the author's to edit.
- */
-export interface IChoiceChipBehavior {
-  /**
-   * Backspace with the cursor right after the chip. `unwrap` (the default)
-   * turns the chip into its value as plain text, the cursor at the end of it,
-   * for the author to edit; `remove` deletes it whole, as the editor deletes
-   * any other chip.
-   */
-  backspace?: 'unwrap' | 'remove';
-  /**
-   * A click on the chip's body. `unwrap` (the default) turns the chip into its
-   * value as plain text, the cursor at the end of it; `cursor` only places the
-   * cursor after it, as a click on a template chip does.
-   */
-  click?: 'unwrap' | 'cursor';
-}
-
-export const DEFAULT_CHOICE_CHIP_BEHAVIOR: Required<IChoiceChipBehavior> = {
-  backspace: 'unwrap',
-  click: 'unwrap',
-};
-
-/** Where the node is in the document, by identity; the editor renders the document's own nodes, so a chip handed to a click handler is one of them. */
-export const pathOfNode = (editor: Editor, node: unknown): Path | undefined => {
-  // Stepped by hand: the build target cannot iterate a generator (TS2802).
-  const nodes = Node.nodes(editor);
-
-  for (let entry = nodes.next(); !entry.done; entry = nodes.next()) {
-    if (entry.value[0] === node) {
-      return entry.value[1];
-    }
-  }
-
-  return undefined;
-};
-
-/**
- * The chip the cursor is on: right after it with nothing between, where
- * Backspace would take it, or inside it, where the arrow keys can leave the
- * cursor. Nothing when the selection spans text or sits anywhere else.
- */
-export const choiceChipAtCursor = (editor: Editor): Path | undefined => {
-  const { selection } = editor;
-
-  if (!selection || !Range.isCollapsed(selection)) {
-    return undefined;
-  }
-
-  const { path, offset } = selection.anchor;
-  const inside = Editor.above(editor, { at: path, match: isChoiceChip, voids: true });
-
-  if (inside) {
-    return inside[1];
-  }
-
-  if (offset !== 0 || !Path.hasPrevious(path)) {
-    return undefined;
-  }
-
-  const previous = Path.previous(path);
-
-  return isChoiceChip(Node.get(editor, previous)) ? previous : undefined;
-};
-
-/**
- * Opens the chip at `path` into its value as plain text, the cursor at the
- * end of the text: what the author read is what they chose, now editable
- * letter by letter. The document is text from here on, and is stored as the
- * field stores anything typed; it is drawn as a chip again only when it is
- * read back as exactly one of the choices.
- */
-export const unwrapChoiceChip = (editor: Editor, path: Path): boolean => {
-  const chip = Node.get(editor, path);
-
-  if (!isChoiceChip(chip)) {
-    return false;
-  }
-
-  Editor.withoutNormalizing(editor, () => {
-    Transforms.removeNodes(editor, { at: path });
-    Transforms.insertNodes(editor, [{ text: chip.value }], { at: path });
-    Transforms.select(editor, Editor.end(editor, path));
-  });
-
-  return true;
-};