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

package/src/components/form/engine/compactToolbarContext.ts

@@ -1,72 +0,0 @@
-import React from 'react';
-import { createContext } from 'use-context-selector';
-
-/** Compact field sort modes (Fields menu → "Sort by"). 'schema' keeps the
- * schema's declared order (the default); the others reorder fields WITHIN each
- * group, with schema order as the stable tiebreaker. */
-export type TCompactSort = 'schema' | 'alpha' | 'alpha-desc' | 'unset' | 'invalid';
-
-/** A not-yet-selected optional field offered in the compact "Fields" menu. */
-export interface ICompactToolbarOptionalField {
-  value: string;
-  display_name?: string;
-  short_desc?: string;
-  disabled?: boolean;
-}
-
-/**
- * The closure surface the extracted `CompactToolbar` reads through context.
- * Assembled (memoised) by `FormEngine` and provided around the compact render,
- * so the toolbar — which Reqore instantiates as a panel header action — can
- * reach the form's state/handlers without threading a props bag through the
- * `actions` descriptor. Primitives (counts, booleans) are passed pre-computed
- * to keep the toolbar decoupled from FormEngine's internals.
- */
-export interface ICompactToolbarContext {
-  readOnly?: boolean;
-  /** Which parts to render, already resolved from the engine's `compactToolbar`
-   *  prop — every key present, no undefined to re-default here. */
-  parts: {
-    completion: boolean;
-    search: boolean;
-    fields: boolean;
-    help: boolean;
-  };
-  // Completion meter
-  invalidCount: number;
-  attentionCount: number;
-  /** How many of `attentionCount` are faults (invalid, or a required field the person
-   *  has been to and left empty). Zero on a fresh form: the rest are only to fill in. */
-  attentionFaultCount: number;
-  completion: { set: number; done: number; total: number; pct: number };
-  // Invalid-fields banner (pinned in the sticky header)
-  showInvalidOnly: boolean;
-  onToggleInvalidOnly: () => void;
-  // Search
-  hasMultipleOptions: boolean;
-  compactQuery: string;
-  setCompactQuery: (value: string) => void;
-  // Fields menu
-  requiredOnly: boolean;
-  setRequiredOnly: React.Dispatch<React.SetStateAction<boolean>>;
-  // Field sort (Fields menu → "Sort by"); applied within groups.
-  compactSort: TCompactSort;
-  setCompactSort: React.Dispatch<React.SetStateAction<TCompactSort>>;
-  showFieldTypes: boolean;
-  onToggleFieldTypes: () => void;
-  // Global field-info toggle (toolbar ⓘ), tri-state: undefined = default
-  // (critical messages auto-open), true = show all, false = hide all.
-  showAllDescriptions: boolean | undefined;
-  onToggleAllDescriptions: () => void;
-  filteredCount: number;
-  optionalFields: ICompactToolbarOptionalField[];
-  canRevert: boolean;
-  onAddOptionalField: (value: unknown) => void;
-  onAddAll: () => void;
-  onResetDefaults: () => void;
-  onRevertAll: () => void;
-}
-
-export const CompactToolbarContext = createContext<ICompactToolbarContext>(
-  {} as ICompactToolbarContext
-);

package/src/components/form/engine/formAppearance.ts

@@ -1,79 +0,0 @@
-import { IReqoreTheme } from '@qoretechnologies/reqore/dist/constants/theme';
-import {
-  changeDarkness,
-  changeLightness,
-  getMainBackgroundColor,
-} from '@qoretechnologies/reqore/dist/helpers/colors';
-import { createContext, useContext } from 'react';
-
-/**
- * How a form looks. The look only: which fields exist, how they bucket, what a
- * click does and what is validated are identical in every appearance.
- *
- * - `'calm'` (the default) — colour only where something needs a person. The
- *   status boxes are plain panels on the theme's panel surface with label/value
- *   rows split by hairlines; labels are grey; a missing required value is an
- *   amber word instead of a red asterisk and message; counts are quiet numbers;
- *   a healthy row carries no dot; Yes/No are plain words; nothing is forced
- *   into uppercase.
- * - `'classic'` — the earlier read-first look, for a host that asks for it:
- *   tinted status boxes, an intent-coloured completion meter, a status dot on
- *   every row.
- */
-export type TFormEngineAppearance = 'calm' | 'classic';
-
-/**
- * The appearance in force for everything below it: the engine's own rows and
- * toolbar, every field editor it mounts, and every nested (`arg_schema`)
- * sub-form, which inherits it unless it is given one of its own.
- *
- * `FormEngine` provides it from its `appearance` prop. A host may also wrap
- * its whole tree in it, to set the appearance once for every form — and for
- * the field components it renders outside a form.
- */
-export const FormAppearanceContext = createContext<TFormEngineAppearance | undefined>(undefined);
-
-export const FormAppearanceProvider = FormAppearanceContext.Provider;
-
-/** The appearance in force here; `'calm'` when nothing set one. */
-export const useFormAppearance = (): TFormEngineAppearance =>
-  useContext(FormAppearanceContext) ?? 'calm';
-
-/** Shorthand for the one question most call sites ask. */
-export const useIsCalmForm = (): boolean => useFormAppearance() === 'calm';
-
-/** The theme's own panel surface, when it declares one (Reqore >= 0.78.6). */
-const getDeclaredPanelSurface = (
-  theme: IReqoreTheme
-): { main?: string; border?: string } | undefined => {
-  const themed = theme as IReqoreTheme & {
-    panel?: { main?: string; border?: string };
-    originalMain?: string;
-  };
-  // Same rule as Reqore's `getThemePanelSurface`: a component whose `main` was
-  // moved off the original (a custom theme, an intent) keeps deriving its own.
-  return themed.panel && (!themed.originalMain || themed.main === themed.originalMain) ?
-      themed.panel
-    : undefined;
-};
-
-/**
- * The surface a calm section paints, matching the one Reqore gives a panel:
- * `theme.panel.main` when the theme declares one, else the panel shade Reqore
- * derives from `main`. Read here rather than through Reqore's own helper so the
- * whole peer range keeps working — the helper arrived after the floor.
- */
-export const getCalmPanelSurface = (theme: IReqoreTheme): string =>
-  getDeclaredPanelSurface(theme)?.main ?? changeDarkness(getMainBackgroundColor(theme), 0.03);
-
-/** The neutral 1px edge of a calm section, and of every row inside it. */
-export const getCalmPanelHairline = (theme: IReqoreTheme): string =>
-  getDeclaredPanelSurface(theme)?.border ?? changeLightness(getMainBackgroundColor(theme), 0.08);
-
-/**
- * What a calm form writes in place of an empty required value. Editable: what
- * to do about it. Read-only: only what is the case, because the reader cannot
- * add anything.
- */
-export const CALM_REQUIRED_LABEL = 'Required · add a value';
-export const CALM_REQUIRED_READ_LABEL = 'Required · not set';

package/src/components/form/engine/optionActions.ts

@@ -1,128 +0,0 @@
-import { IReqoreDropdownItem } from '@qoretechnologies/reqore/dist/components/Dropdown/list';
-import {
-  IReqorePanelAction,
-  IReqorePanelSubAction,
-} from '@qoretechnologies/reqore/dist/components/Panel';
-import { IQorusFormField, IQorusFormSchema } from '@qoretechnologies/ts-toolkit';
-
-/**
- * The context an `optionActions` factory receives for a single option — the
- * option's name, its schema entry, and its current field value. This is the
- * IDE's `AiAssistanceAction` context (it injects its `allowAi` button here).
- */
-export interface IOptionActionsContext {
-  name: string;
-  schema: IQorusFormSchema[string];
-  value?: IQorusFormField;
-}
-
-/**
- * SEAM (reqraft): per-option injected actions. Either a static list applied to
- * every option, or a factory invoked once per option with that option's context.
- */
-export type TOptionActions =
-  | IReqorePanelAction[]
-  | ((context: IOptionActionsContext) => IReqorePanelAction[]);
-
-/**
- * Resolve the `optionActions` seam for one option.
- *
- * Both render paths go through this so a consumer's factory is called with the
- * same context and its result shaped the same way: the classic path feeds the
- * result to `ReqorePanel`'s `actions`, the compact path renders the buttons
- * itself. Falsy entries are dropped so a factory can return conditional actions
- * inline (`cond && {...}`) without each caller re-filtering.
- */
-export const resolveOptionActions = (
-  optionActions: TOptionActions | undefined,
-  context: IOptionActionsContext
-): IReqorePanelAction[] => {
-  const actions =
-    typeof optionActions === 'function' ? optionActions(context) : (optionActions ?? []);
-
-  return (actions ?? []).filter((action): action is IReqorePanelAction => !!action);
-};
-
-/** How many injected actions a row shows as buttons before the rest go into its menu. */
-export const MAX_INLINE_OPTION_ACTIONS = 2;
-
-/**
- * Which injected actions stay as buttons, and which move into the row's menu.
- *
- * Everything moves on touch and on narrow viewports (`collapse`) — a button
- * that waits for a hover is unreachable without one — and anything past the
- * inline cap moves regardless, so a consumer injecting ten actions can never
- * push the row's value out of view. Both render paths decide it here.
- */
-export const splitOptionActions = (
-  actions: IReqorePanelAction[],
-  collapse: boolean
-): [IReqorePanelAction[], IReqorePanelAction[]] =>
-  collapse ?
-    [[], actions]
-  : [actions.slice(0, MAX_INLINE_OPTION_ACTIONS), actions.slice(MAX_INLINE_OPTION_ACTIONS)];
-
-/**
- * An injected action as a row in a menu.
- *
- * A panel action labels itself with `label`, but an icon-only one (the IDE's
- * AI-assist button) carries its name in the tooltip — and a menu row has no
- * hover to fall back on.
- */
-export const optionActionAsMenuItem = (
-  action: IReqorePanelAction,
-  index: number
-): IReqoreDropdownItem => ({
-  /* A menu row's label has to be text. `tooltip` may be a tooltip OBJECT
-     (`IReqoreTooltip`), which is why this was cast before — an action with a
-     configured tooltip and no label put that object where a string belongs. */
-  label:
-    action.label ??
-    (typeof action.tooltip === 'string' ? action.tooltip : undefined) ??
-    `Action ${index + 1}`,
-  icon: action.icon,
-  intent: action.intent,
-  disabled: action.disabled,
-  className: action.className,
-  onClick: () => action.onClick?.(),
-});
-
-export interface IOptionRowActionsInput {
-  /** The consumer's actions for this option, already resolved. */
-  injected: IReqorePanelAction[];
-  /** Move every injected action into the menu (touch, narrow viewport). */
-  collapse: boolean;
-  /** The row's own secondary actions; a falsy entry is one that does not apply. */
-  menu: (IReqorePanelSubAction | false | null | undefined | 0 | '')[];
-}
-
-/**
- * A classic form row's header actions.
- *
- * Injected actions stay as buttons up to the inline cap; the rest, and the
- * row's own secondary actions, go into ONE ⋯ menu that is always drawn, so
- * nothing the row offers is reachable only by hovering it.
- */
-export const optionRowActions = ({
-  injected,
-  collapse,
-  menu,
-}: IOptionRowActionsInput): IReqorePanelAction[] => {
-  const [inline, overflow] = splitOptionActions(injected, collapse);
-  const items: IReqorePanelSubAction[] = [
-    ...overflow.map(optionActionAsMenuItem),
-    ...menu.filter((item): item is IReqorePanelSubAction => !!item),
-  ];
-
-  const more: IReqorePanelAction = {
-    icon: 'More2Fill',
-    size: 'tiny',
-    minimal: true,
-    flat: true,
-    className: 'options-item-more',
-    tooltip: 'More actions',
-    actions: items,
-  };
-
-  return [...inline, ...(items.length ? [more] : [])];
-};

package/src/components/form/engine/optionsContext.ts

@@ -1,24 +0,0 @@
-import { IQorusFormSchema, TQorusForm } from '@qoretechnologies/ts-toolkit';
-import { createContext } from 'use-context-selector';
-
-/** The form a field is standing in: what it declares, and what it currently holds. */
-export interface IOptionsContext {
-  schema?: IQorusFormSchema;
-  value?: TQorusForm;
-}
-
-/**
- * The surrounding form, for a renderer that has to judge one field against its
- * SIBLINGS — an allowed value gated on another field's answer, for instance.
- *
- * It lives in a module of its own rather than in `FormEngine`, which imports
- * the field renderers that read it: a renderer importing the engine back would
- * close a cycle around a value created at module scope, and the context would
- * be `undefined` for whichever module happened to be evaluated first.
- *
- * An empty default is load-bearing. `value` is `undefined` only when there is
- * no form around the renderer at all — a picker mounted on its own, a story, a
- * test — and a predicate about siblings has nothing to say there. Inside a form
- * it is always an object, empty or not.
- */
-export const OptionsContext = createContext<IOptionsContext>({});