@qoretechnologies/reqraft 0.10.55-pr.124.g43fa138 → 0.10.55

package/dist/components/form/engine/rendererTypes.d.ts

@@ -1,4 +1,35 @@
-import { TQorusType } from '@qoretechnologies/ts-toolkit';
+import { IReqoreFormTemplates } from '@qoretechnologies/reqore/dist/components/Textarea';
+/**
+ * A field schema that carries a template list of its own.
+ *
+ * `templates` is deliberately NOT added to `TQorusFormFieldSchema`: that type is
+ * owned by ts-toolkit and shared with consumers that have no notion of a form
+ * engine, so the capability is read through this narrow view instead of widening
+ * the shared type from here. A schema that sets it is offering a list scoped to
+ * one field rather than to the whole form.
+ */
+export type TFieldWithOwnTemplates = {
+    templates?: IReqoreFormTemplates;
+    /**
+     * The token grammar this field's value is WRITTEN in.
+     *
+     * A host may spell a reference in a grammar that is not reqraft's — a Qorus
+     * test writes `$._case.mode`, which has no `$key:` in it at all — and a field
+     * that speaks one says so here, exactly as it hands down its own `templates`.
+     * Declaring it on the schema is what lets every surface that draws the value
+     * agree about it, instead of printing the raw token the author never typed.
+     *
+     * Both directions read it: the read-only renderings
+     * (`templateTextSegments`) and the rich-text editor a row opens
+     * (`templateTextToNodes`, through `RichTextFormField`'s `templateToken`
+     * prop). They resolve references with the same code, so a row and the editor
+     * it opens cannot disagree about what one is.
+     *
+     * A `RegExp` or its source: a schema that crossed a serialization boundary
+     * carries the string.
+     */
+    templateToken?: RegExp | string;
+};
 /**
  * A schema entry carries two type-ish keys with different jobs:
  *
@@ -27,6 +58,14 @@ import { TQorusType } from '@qoretechnologies/ts-toolkit';
  * and neither ever fires.
  */
 export declare const BUILT_IN_RENDERER_ONLY_UI_TYPES: readonly string[];
+/**
+ * A `ui_type` as the predicate takes it: any name, not only a `TQorusType`.
+ * The names it exists to recognise are open-ended — `cron` is not a
+ * `TQorusType`, and neither is an editor a consumer declares — so typing the
+ * argument as the shared union made the predicate uncallable for exactly the
+ * values it is for.
+ */
+export type TRendererTypeName = string | readonly string[];
 /**
  * Build the renderer-only predicate for one FormEngine instance.
  *
@@ -36,7 +75,7 @@ export declare const BUILT_IN_RENDERER_ONLY_UI_TYPES: readonly string[];
  * its own without waiting on a reqraft release, which is what previously made
  * every new IDE editor a silent value-corruption bug until this list caught up.
  */
-export declare const createRendererOnlyUiTypeCheck: (extraTypes?: readonly string[]) => ((type?: TQorusType | TQorusType[]) => boolean);
+export declare const createRendererOnlyUiTypeCheck: (extraTypes?: readonly string[]) => ((type?: TRendererTypeName) => boolean);
 /** The default predicate — built-ins only, for module-scope callers with no props. */
-export declare const isRendererOnlyUiType: (type?: TQorusType | TQorusType[]) => boolean;
+export declare const isRendererOnlyUiType: (type?: TRendererTypeName) => boolean;
 //# sourceMappingURL=rendererTypes.d.ts.map

package/dist/components/form/engine/rendererTypes.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"rendererTypes.d.ts","sourceRoot":"","sources":["../../../../src/components/form/engine/rendererTypes.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,8BAA8B,CAAC;AAE1D;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,eAAO,MAAM,+BAA+B,EAAE,SAAS,MAAM,EAY5D,CAAC;AAEF;;;;;;;;GAQG;AACH,eAAO,MAAM,6BAA6B,gBAC3B,SAAS,MAAM,EAAE,KAC7B,CAAC,CAAC,IAAI,CAAC,EAAE,UAAU,GAAG,UAAU,EAAE,KAAK,OAAO,CAKhD,CAAC;AAEF,sFAAsF;AACtF,eAAO,MAAM,oBAAoB,UARrB,UAAU,GAAG,UAAU,EAAE,KAAK,OAQyB,CAAC"}
+{"version":3,"file":"rendererTypes.d.ts","sourceRoot":"","sources":["../../../../src/components/form/engine/rendererTypes.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,oBAAoB,EAAE,MAAM,mDAAmD,CAAC;AAGzF;;;;;;;;GAQG;AACH,MAAM,MAAM,sBAAsB,GAAG;IACnC,SAAS,CAAC,EAAE,oBAAoB,CAAC;IACjC;;;;;;;;;;;;;;;;;OAiBG;IACH,aAAa,CAAC,EAAE,MAAM,GAAG,MAAM,CAAC;CACjC,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,eAAO,MAAM,+BAA+B,EAAE,SAAS,MAAM,EAY5D,CAAC;AAEF;;;;;;GAMG;AACH,MAAM,MAAM,iBAAiB,GAAG,MAAM,GAAG,SAAS,MAAM,EAAE,CAAC;AAE3D;;;;;;;;GAQG;AACH,eAAO,MAAM,6BAA6B,gBAC3B,SAAS,MAAM,EAAE,KAC7B,CAAC,CAAC,IAAI,CAAC,EAAE,iBAAiB,KAAK,OAAO,CAOxC,CAAC;AAEF,sFAAsF;AACtF,eAAO,MAAM,oBAAoB,UAVrB,iBAAiB,KAAK,OAUiC,CAAC"}

package/dist/components/form/engine/rendererTypes.js

@@ -10,6 +10,7 @@ var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.isRendererOnlyUiType = exports.createRendererOnlyUiTypeCheck = exports.BUILT_IN_RENDERER_ONLY_UI_TYPES = void 0;
+var optionUiTypes_1 = require("../../../helpers/optionUiTypes");
 /**
  * A schema entry carries two type-ish keys with different jobs:
  *
@@ -62,7 +63,8 @@ exports.BUILT_IN_RENDERER_ONLY_UI_TYPES = [
 var createRendererOnlyUiTypeCheck = function (extraTypes) {
     var known = new Set(__spreadArray(__spreadArray([], exports.BUILT_IN_RENDERER_ONLY_UI_TYPES, true), (extraTypes !== null && extraTypes !== void 0 ? extraTypes : []), true));
     return function (type) {
-        return typeof type === 'string' && known.has(type);
+        var declared = (0, optionUiTypes_1.firstDeclaredType)(type);
+        return declared !== undefined && known.has(declared);
     };
 };
 exports.createRendererOnlyUiTypeCheck = createRendererOnlyUiTypeCheck;

package/dist/components/form/engine/rendererTypes.js.map

@@ -1 +1 @@
-{"version":3,"file":"rendererTypes.js","sourceRoot":"","sources":["../../../../src/components/form/engine/rendererTypes.ts"],"names":[],"mappings":";;;;;;;;;;;;AAEA;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACU,QAAA,+BAA+B,GAAsB;IAChE,gBAAgB;IAChB,iBAAiB;IACjB,aAAa;IACb,MAAM;IACN,MAAM;IACN,UAAU;IACV,oBAAoB;IACpB,mBAAmB;IACnB,YAAY;IACZ,qBAAqB;IACrB,cAAc;CACf,CAAC;AAEF;;;;;;;;GAQG;AACI,IAAM,6BAA6B,GAAG,UAC3C,UAA8B;IAE9B,IAAM,KAAK,GAAG,IAAI,GAAG,iCAAa,uCAA+B,SAAK,CAAC,UAAU,aAAV,UAAU,cAAV,UAAU,GAAI,EAAE,CAAC,QAAE,CAAC;IAE3F,OAAO,UAAC,IAAgC;QACtC,OAAA,OAAO,IAAI,KAAK,QAAQ,IAAI,KAAK,CAAC,GAAG,CAAC,IAAI,CAAC;IAA3C,CAA2C,CAAC;AAChD,CAAC,CAAC;AAPW,QAAA,6BAA6B,iCAOxC;AAEF,sFAAsF;AACzE,QAAA,oBAAoB,GAAG,IAAA,qCAA6B,GAAE,CAAC"}
+{"version":3,"file":"rendererTypes.js","sourceRoot":"","sources":["../../../../src/components/form/engine/rendererTypes.ts"],"names":[],"mappings":";;;;;;;;;;;;AACA,gEAAmE;AAkCnE;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACU,QAAA,+BAA+B,GAAsB;IAChE,gBAAgB;IAChB,iBAAiB;IACjB,aAAa;IACb,MAAM;IACN,MAAM;IACN,UAAU;IACV,oBAAoB;IACpB,mBAAmB;IACnB,YAAY;IACZ,qBAAqB;IACrB,cAAc;CACf,CAAC;AAWF;;;;;;;;GAQG;AACI,IAAM,6BAA6B,GAAG,UAC3C,UAA8B;IAE9B,IAAM,KAAK,GAAG,IAAI,GAAG,iCAAa,uCAA+B,SAAK,CAAC,UAAU,aAAV,UAAU,cAAV,UAAU,GAAI,EAAE,CAAC,QAAE,CAAC;IAE3F,OAAO,UAAC,IAAwB;QAC9B,IAAM,QAAQ,GAAG,IAAA,iCAAiB,EAAC,IAAI,CAAC,CAAC;QACzC,OAAO,QAAQ,KAAK,SAAS,IAAI,KAAK,CAAC,GAAG,CAAC,QAAQ,CAAC,CAAC;IACvD,CAAC,CAAC;AACJ,CAAC,CAAC;AATW,QAAA,6BAA6B,iCASxC;AAEF,sFAAsF;AACzE,QAAA,oBAAoB,GAAG,IAAA,qCAA6B,GAAE,CAAC"}

package/dist/components/form/engine/rowFocus.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Which control an open compact row hands the caret to.
+ *
+ * A row's editor is whatever the field's type asks for, and only some of those
+ * take typed text. A pick-one renders `ReqoreCheckbox`es (a `[tabindex]`
+ * element), a selector renders a `<button>`, a code field a `[contenteditable]`
+ * — so a scan that looked for `input`, `textarea` and `[contenteditable]` alone
+ * found nothing on most of the first questions a form asks ("which kind?",
+ * "which connection?", "which interface?"). The row opened and the caret stayed
+ * on whatever made it open.
+ *
+ * Text entry wins when the row offers it. Every editor that takes typing also
+ * draws affordances around it — a template picker, a type menu, a clear button
+ * — and those come first in document order often enough that "the first
+ * focusable element" would answer a text field with a button beside it.
+ */
+/**
+ * The control an open row should focus, or `undefined` when it offers none —
+ * a read-only preview, or an editor that has not mounted yet (see the caller,
+ * which watches for it to arrive).
+ *
+ * @param container the row's value cell
+ */
+export declare const findRowFocusTarget: (container: HTMLElement | null | undefined) => HTMLElement | undefined;
+/**
+ * Whether this control is a picker that is still closed — i.e. whether
+ * activating it is what "open the editor" means for this row.
+ */
+export declare const isClosedPickerTrigger: (element: HTMLElement | null | undefined) => boolean;
+//# sourceMappingURL=rowFocus.d.ts.map

package/dist/components/form/engine/rowFocus.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"rowFocus.d.ts","sourceRoot":"","sources":["../../../../src/components/form/engine/rowFocus.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAwCH;;;;;;GAMG;AACH,eAAO,MAAM,kBAAkB,cAClB,WAAW,GAAG,IAAI,GAAG,SAAS,KACxC,WAAW,GAAG,SAOhB,CAAC;AAqBF;;;GAGG;AACH,eAAO,MAAM,qBAAqB,YAAa,WAAW,GAAG,IAAI,GAAG,SAAS,KAAG,OAI9B,CAAC"}

package/dist/components/form/engine/rowFocus.js

@@ -0,0 +1,93 @@
+"use strict";
+/**
+ * Which control an open compact row hands the caret to.
+ *
+ * A row's editor is whatever the field's type asks for, and only some of those
+ * take typed text. A pick-one renders `ReqoreCheckbox`es (a `[tabindex]`
+ * element), a selector renders a `<button>`, a code field a `[contenteditable]`
+ * — so a scan that looked for `input`, `textarea` and `[contenteditable]` alone
+ * found nothing on most of the first questions a form asks ("which kind?",
+ * "which connection?", "which interface?"). The row opened and the caret stayed
+ * on whatever made it open.
+ *
+ * Text entry wins when the row offers it. Every editor that takes typing also
+ * draws affordances around it — a template picker, a type menu, a clear button
+ * — and those come first in document order often enough that "the first
+ * focusable element" would answer a text field with a button beside it.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isClosedPickerTrigger = exports.findRowFocusTarget = void 0;
+/** Controls the reader types into. */
+var TEXT_ENTRY_SELECTOR = 'input:not([type="hidden"]):not([disabled]), textarea:not([disabled]), [contenteditable="true"]';
+/**
+ * Everything else a row can offer. `[tabindex]` is what carries reqore's own
+ * controls: a checkbox is an icon element made focusable, not an `<input>`.
+ */
+var OTHER_CONTROL_SELECTOR = 'button:not([disabled]), select:not([disabled]), [tabindex]:not([tabindex="-1"])';
+/**
+ * Subtrees inside the row's value cell that are NOT this field's editor: a
+ * sibling field absorbed into this row (a different field, which the engine did
+ * not open) and the schema-message strip above the editor (guidance about the
+ * value, never a place to put one).
+ */
+var NOT_THE_FIELDS_OWN_EDITOR = '.options-readfirst-absorbed, .options-readfirst-info-panel';
+var belongsToTheFieldsOwnEditor = function (container, element) {
+    var foreign = element.closest(NOT_THE_FIELDS_OWN_EDITOR);
+    // `closest` walks past the container too, so a match only disqualifies the
+    // element when it is inside THIS container.
+    return !foreign || !container.contains(foreign);
+};
+var firstMatch = function (container, selector) {
+    var matches = Array.from(container.querySelectorAll(selector));
+    return matches.find(function (element) {
+        return belongsToTheFieldsOwnEditor(container, element) &&
+            // An element hidden from assistive technology is not a destination for a
+            // caret either — reqore draws decorative, focusable-looking chrome that
+            // way.
+            !element.closest('[aria-hidden="true"]');
+    });
+};
+/**
+ * The control an open row should focus, or `undefined` when it offers none —
+ * a read-only preview, or an editor that has not mounted yet (see the caller,
+ * which watches for it to arrive).
+ *
+ * @param container the row's value cell
+ */
+var findRowFocusTarget = function (container) {
+    var _a;
+    if (!container) {
+        return undefined;
+    }
+    return ((_a = firstMatch(container, TEXT_ENTRY_SELECTOR)) !== null && _a !== void 0 ? _a : firstMatch(container, OTHER_CONTROL_SELECTOR));
+};
+exports.findRowFocusTarget = findRowFocusTarget;
+/**
+ * Controls whose ONLY behaviour is to reveal the choices.
+ *
+ * A row that opens hands the caret to the control it offers, and for most
+ * editors that is the end of it: a text box takes typing, a pick-one's
+ * checkboxes take a click. A PICKER is different — its closed state prints the
+ * value it already holds, which is the very thing the read row printed, so
+ * opening the row changed nothing on screen and the author had to click a
+ * second time to see the list. Read-first belongs to the collapsed row; it must
+ * not be the answer twice.
+ *
+ * Declared with `aria-haspopup`, which is what the attribute means and is
+ * already the contract with assistive technology — so a host's own editor opts
+ * in by being accessible rather than by knowing about this file. `aria-expanded`
+ * is respected: a picker that is already showing its list is not re-activated.
+ */
+var PICKER_TRIGGER_SELECTOR = '[aria-haspopup="listbox"], [aria-haspopup="dialog"], [aria-haspopup="menu"], [aria-haspopup="tree"], [aria-haspopup="grid"]';
+/**
+ * Whether this control is a picker that is still closed — i.e. whether
+ * activating it is what "open the editor" means for this row.
+ */
+var isClosedPickerTrigger = function (element) {
+    return !!element &&
+        typeof element.matches === 'function' &&
+        element.matches(PICKER_TRIGGER_SELECTOR) &&
+        element.getAttribute('aria-expanded') !== 'true';
+};
+exports.isClosedPickerTrigger = isClosedPickerTrigger;
+//# sourceMappingURL=rowFocus.js.map

package/dist/components/form/engine/rowFocus.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"rowFocus.js","sourceRoot":"","sources":["../../../../src/components/form/engine/rowFocus.ts"],"names":[],"mappings":";AAAA;;;;;;;;;;;;;;;GAeG;;;AAEH,sCAAsC;AACtC,IAAM,mBAAmB,GACvB,gGAAgG,CAAC;AAEnG;;;GAGG;AACH,IAAM,sBAAsB,GAC1B,iFAAiF,CAAC;AAEpF;;;;;GAKG;AACH,IAAM,yBAAyB,GAAG,4DAA4D,CAAC;AAE/F,IAAM,2BAA2B,GAAG,UAAC,SAAsB,EAAE,OAAgB;IAC3E,IAAM,OAAO,GAAG,OAAO,CAAC,OAAO,CAAC,yBAAyB,CAAC,CAAC;IAC3D,2EAA2E;IAC3E,4CAA4C;IAC5C,OAAO,CAAC,OAAO,IAAI,CAAC,SAAS,CAAC,QAAQ,CAAC,OAAO,CAAC,CAAC;AAClD,CAAC,CAAC;AAEF,IAAM,UAAU,GAAG,UAAC,SAAsB,EAAE,QAAgB;IAC1D,IAAM,OAAO,GAAG,KAAK,CAAC,IAAI,CAAC,SAAS,CAAC,gBAAgB,CAAc,QAAQ,CAAC,CAAC,CAAC;IAC9E,OAAO,OAAO,CAAC,IAAI,CACjB,UAAC,OAAO;QACN,OAAA,2BAA2B,CAAC,SAAS,EAAE,OAAO,CAAC;YAC/C,yEAAyE;YACzE,wEAAwE;YACxE,OAAO;YACP,CAAC,OAAO,CAAC,OAAO,CAAC,sBAAsB,CAAC;IAJxC,CAIwC,CAC3C,CAAC;AACJ,CAAC,CAAC;AAEF;;;;;;GAMG;AACI,IAAM,kBAAkB,GAAG,UAChC,SAAyC;;IAEzC,IAAI,CAAC,SAAS,EAAE,CAAC;QACf,OAAO,SAAS,CAAC;IACnB,CAAC;IACD,OAAO,CACL,MAAA,UAAU,CAAC,SAAS,EAAE,mBAAmB,CAAC,mCAAI,UAAU,CAAC,SAAS,EAAE,sBAAsB,CAAC,CAC5F,CAAC;AACJ,CAAC,CAAC;AATW,QAAA,kBAAkB,sBAS7B;AAEF;;;;;;;;;;;;;;;GAeG;AACH,IAAM,uBAAuB,GAC3B,6HAA6H,CAAC;AAEhI;;;GAGG;AACI,IAAM,qBAAqB,GAAG,UAAC,OAAuC;IAC3E,OAAA,CAAC,CAAC,OAAO;QACT,OAAO,OAAO,CAAC,OAAO,KAAK,UAAU;QACrC,OAAO,CAAC,OAAO,CAAC,uBAAuB,CAAC;QACxC,OAAO,CAAC,YAAY,CAAC,eAAe,CAAC,KAAK,MAAM;AAHhD,CAGgD,CAAC;AAJtC,QAAA,qBAAqB,yBAIiB"}

package/dist/components/form/engine/rowMenuContext.d.ts

@@ -0,0 +1,78 @@
+/// <reference types="react" />
+import { IReqoreDropdownItem } from '@qoretechnologies/reqore/dist/components/Dropdown/list';
+/**
+ * SEAM (reqraft): an editor publishes its own actions into the row's ⋮ menu.
+ *
+ * A row already renders one overflow menu — Edit fullscreen, Remove field, and
+ * any `optionActions` the host injected — and the comment on it has always said
+ * why: *"this row already has a menu, so they reuse it rather than adding a
+ * second one beside it."* An EDITOR could not reach that menu, so an editor
+ * with affordances of its own had no choice but to draw a second ⋮ inside the
+ * value cell. The IDE's template field does exactly that, and the two menus
+ * ended up side by side on one control, at slightly different widths.
+ *
+ * `optionActions` does not solve it: that seam is host configuration, resolved
+ * from the option's name and schema before the editor exists, so it cannot know
+ * what the editor can offer *now* — whether its templates have loaded, whether
+ * the value is already an expression, which custom items the field was given.
+ *
+ * ## Why registration is keyed, and by whom
+ *
+ * Menu items carry `onClick` handlers, so they are a new array on every render
+ * and cannot be compared by value. An editor therefore publishes a `key`
+ * alongside them: a primitive describing WHICH items it is currently offering
+ * (`'expression,template'`). The row re-renders only when a publisher's key
+ * changes, so a re-rendering editor cannot drive the row into a state loop.
+ *
+ * Each registration also belongs to ONE publisher. A single shared slot let
+ * two publishers in the same row — an expression builder's operands — overwrite
+ * each other's key on every render, which re-rendered the row and both of them,
+ * which published again: a synchronous render loop that froze the page. And a
+ * slot that outlived its editor kept that editor's handlers after it unmounted,
+ * so a row closed and reopened offered items that did nothing. Registrations
+ * are therefore per publisher, withdrawn on unmount, and a click always reaches
+ * the handler from the publisher's latest render.
+ *
+ * Publish with `useRowMenuPublisher`; provide with `useRowMenuRegistry`.
+ */
+export interface IRowMenuRegistration {
+    /**
+     * Publish a publisher's menu items into the containing row's ⋮.
+     *
+     * @param publisherId identifies the publishing editor (one per mounted editor)
+     * @param key a primitive describing which items are being offered; the row
+     * re-renders only when it changes
+     * @param items the items to merge, or an empty array to contribute none
+     */
+    registerRowMenuItems: (publisherId: string, key: string, items: IReqoreDropdownItem[]) => void;
+    /** Withdraw a publisher's items — when it unmounts or leaves the row. */
+    unregisterRowMenuItems: (publisherId: string) => void;
+}
+/**
+ * Absent outside a compact row — the classic (non-compact) render path has no
+ * row menu to merge into, and an editor there keeps drawing its own control.
+ */
+export declare const RowMenuContext: import("react").Context<IRowMenuRegistration>;
+/**
+ * The row-menu channel for the row this editor is inside, or `undefined` when
+ * there is no row menu to publish into.
+ *
+ * An editor that finds it should render no menu of its own; one that does not
+ * must keep rendering its own, or its actions become unreachable.
+ */
+export declare const useRowMenu: () => IRowMenuRegistration | undefined;
+/**
+ * Publish `items` into `rowMenu` for as long as the calling editor is mounted.
+ * `rowMenu` is passed rather than read here so an editor can claim the channel
+ * and hide it from what it renders (see `TemplateField`).
+ */
+export declare const useRowMenuPublisher: (rowMenu: IRowMenuRegistration | undefined, key: string, items: IReqoreDropdownItem[]) => void;
+/**
+ * The row side of the channel: the registration to provide, and the items the
+ * row's ⋮ should list.
+ */
+export declare const useRowMenuRegistry: () => {
+    rowMenu: IRowMenuRegistration;
+    items: IReqoreDropdownItem[];
+};
+//# sourceMappingURL=rowMenuContext.d.ts.map

package/dist/components/form/engine/rowMenuContext.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"rowMenuContext.d.ts","sourceRoot":"","sources":["../../../../src/components/form/engine/rowMenuContext.ts"],"names":[],"mappings":";AACA,OAAO,EAAE,mBAAmB,EAAE,MAAM,wDAAwD,CAAC;AAY7F;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkCG;AACH,MAAM,WAAW,oBAAoB;IACnC;;;;;;;OAOG;IACH,oBAAoB,EAAE,CAAC,WAAW,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,mBAAmB,EAAE,KAAK,IAAI,CAAC;IAC/F,yEAAyE;IACzE,sBAAsB,EAAE,CAAC,WAAW,EAAE,MAAM,KAAK,IAAI,CAAC;CACvD;AAED;;;GAGG;AACH,eAAO,MAAM,cAAc,+CAA6D,CAAC;AAEzF;;;;;;GAMG;AACH,eAAO,MAAM,UAAU,QAAO,oBAAoB,GAAG,SAAuC,CAAC;AAE7F;;;;GAIG;AACH,eAAO,MAAM,mBAAmB,YACrB,oBAAoB,GAAG,SAAS,OACpC,MAAM,SACJ,mBAAmB,EAAE,KAC3B,IAQF,CAAC;AAEF;;;GAGG;AACH,eAAO,MAAM,kBAAkB,QAAO;IACpC,OAAO,EAAE,oBAAoB,CAAC;IAC9B,KAAK,EAAE,mBAAmB,EAAE,CAAC;CAwD9B,CAAC"}

package/dist/components/form/engine/rowMenuContext.js

@@ -0,0 +1,103 @@
+"use strict";
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useRowMenuRegistry = exports.useRowMenuPublisher = exports.useRowMenu = exports.RowMenuContext = void 0;
+var react_1 = require("react");
+/**
+ * Absent outside a compact row — the classic (non-compact) render path has no
+ * row menu to merge into, and an editor there keeps drawing its own control.
+ */
+exports.RowMenuContext = (0, react_1.createContext)(undefined);
+/**
+ * The row-menu channel for the row this editor is inside, or `undefined` when
+ * there is no row menu to publish into.
+ *
+ * An editor that finds it should render no menu of its own; one that does not
+ * must keep rendering its own, or its actions become unreachable.
+ */
+var useRowMenu = function () { return (0, react_1.useContext)(exports.RowMenuContext); };
+exports.useRowMenu = useRowMenu;
+/**
+ * Publish `items` into `rowMenu` for as long as the calling editor is mounted.
+ * `rowMenu` is passed rather than read here so an editor can claim the channel
+ * and hide it from what it renders (see `TemplateField`).
+ */
+var useRowMenuPublisher = function (rowMenu, key, items) {
+    var publisherId = (0, react_1.useId)();
+    (0, react_1.useEffect)(function () {
+        rowMenu === null || rowMenu === void 0 ? void 0 : rowMenu.registerRowMenuItems(publisherId, key, items);
+    }, [rowMenu, publisherId, key, items]);
+    (0, react_1.useEffect)(function () { return function () { return rowMenu === null || rowMenu === void 0 ? void 0 : rowMenu.unregisterRowMenuItems(publisherId); }; }, [rowMenu, publisherId]);
+};
+exports.useRowMenuPublisher = useRowMenuPublisher;
+/**
+ * The row side of the channel: the registration to provide, and the items the
+ * row's ⋮ should list.
+ */
+var useRowMenuRegistry = function () {
+    // Which publishers are offering which item SET — the only state, so only a
+    // change of set re-renders the row.
+    var _a = (0, react_1.useState)({}), keys = _a[0], setKeys = _a[1];
+    // Each publisher's items from its latest render, read at click time.
+    var latest = (0, react_1.useRef)({});
+    var registerRowMenuItems = (0, react_1.useCallback)(function (publisherId, key, items) {
+        latest.current[publisherId] = items;
+        setKeys(function (previous) {
+            var _a;
+            return previous[publisherId] === key ? previous : __assign(__assign({}, previous), (_a = {}, _a[publisherId] = key, _a));
+        });
+    }, []);
+    var unregisterRowMenuItems = (0, react_1.useCallback)(function (publisherId) {
+        delete latest.current[publisherId];
+        setKeys(function (previous) {
+            if (!(publisherId in previous)) {
+                return previous;
+            }
+            var next = __assign({}, previous);
+            delete next[publisherId];
+            return next;
+        });
+    }, []);
+    var rowMenu = (0, react_1.useMemo)(function () { return ({ registerRowMenuItems: registerRowMenuItems, unregisterRowMenuItems: unregisterRowMenuItems }); }, [registerRowMenuItems, unregisterRowMenuItems]);
+    var items = (0, react_1.useMemo)(function () {
+        return Object.keys(keys).flatMap(function (publisherId) {
+            var _a;
+            return ((_a = latest.current[publisherId]) !== null && _a !== void 0 ? _a : []).map(function (item, index) {
+                return item.onClick
+                    ? __assign(__assign({}, item), { 
+                        // Same key, same item set, so the index still names this item;
+                        // the handler is whatever the publisher rendered last.
+                        onClick: (function () {
+                            var _a, _b, _c;
+                            var args = [];
+                            for (var _i = 0; _i < arguments.length; _i++) {
+                                args[_i] = arguments[_i];
+                            }
+                            return (_c = (_b = (_a = latest.current[publisherId]) === null || _a === void 0 ? void 0 : _a[index]) === null || _b === void 0 ? void 0 : _b.onClick) === null || _c === void 0 ? void 0 : _c.call.apply(_c, __spreadArray([_b], args, false));
+                        }) }) : item;
+            });
+        });
+    }, [keys]);
+    return { rowMenu: rowMenu, items: items };
+};
+exports.useRowMenuRegistry = useRowMenuRegistry;
+//# sourceMappingURL=rowMenuContext.js.map

package/dist/components/form/engine/rowMenuContext.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"rowMenuContext.js","sourceRoot":"","sources":["../../../../src/components/form/engine/rowMenuContext.ts"],"names":[],"mappings":"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"}

package/dist/components/form/engine/rowOpenPicker.d.ts

@@ -0,0 +1,27 @@
+/// <reference types="react" />
+/**
+ * "The row you are in has just been opened, and the control you are is the one
+ * it offers — so show the choices."
+ *
+ * A compact row is read-first: collapsed, it prints the value; clicked, it
+ * mounts the editor. For a PICKER the editor is a closed trigger printing the
+ * same value the read row had just printed, so the row opened and nothing on
+ * screen changed — the author had to click a second time to reach the list.
+ * Read-first is the collapsed row's job; it must not be the answer twice.
+ *
+ * The row decides, because only the row knows both things that matter: that the
+ * AUTHOR opened it (a row the form opens to show a value must not throw a list
+ * over it) and WHICH control it offers (`findRowFocusTarget` — the same scan
+ * that hands over the caret). The control obeys, because only the control knows
+ * how it opens.
+ *
+ * A one-shot pulse rather than a standing flag: it is `true` for exactly the
+ * commit in which the editor acts on it, and false again afterwards, so an
+ * editor that remounts later — a picker whose catalogue reloaded, after the
+ * author had closed it — does not reopen itself off a stale instruction.
+ *
+ * Exported so a host's own editor can obey it too: read it with
+ * `useContext(RowOpenPickerContext)` and open on the rising edge.
+ */
+export declare const RowOpenPickerContext: import("react").Context<boolean>;
+//# sourceMappingURL=rowOpenPicker.d.ts.map

package/dist/components/form/engine/rowOpenPicker.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"rowOpenPicker.d.ts","sourceRoot":"","sources":["../../../../src/components/form/engine/rowOpenPicker.ts"],"names":[],"mappings":";AAEA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,eAAO,MAAM,oBAAoB,kCAAgC,CAAC"}

package/dist/components/form/engine/rowOpenPicker.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RowOpenPickerContext = void 0;
+var react_1 = require("react");
+/**
+ * "The row you are in has just been opened, and the control you are is the one
+ * it offers — so show the choices."
+ *
+ * A compact row is read-first: collapsed, it prints the value; clicked, it
+ * mounts the editor. For a PICKER the editor is a closed trigger printing the
+ * same value the read row had just printed, so the row opened and nothing on
+ * screen changed — the author had to click a second time to reach the list.
+ * Read-first is the collapsed row's job; it must not be the answer twice.
+ *
+ * The row decides, because only the row knows both things that matter: that the
+ * AUTHOR opened it (a row the form opens to show a value must not throw a list
+ * over it) and WHICH control it offers (`findRowFocusTarget` — the same scan
+ * that hands over the caret). The control obeys, because only the control knows
+ * how it opens.
+ *
+ * A one-shot pulse rather than a standing flag: it is `true` for exactly the
+ * commit in which the editor acts on it, and false again afterwards, so an
+ * editor that remounts later — a picker whose catalogue reloaded, after the
+ * author had closed it — does not reopen itself off a stale instruction.
+ *
+ * Exported so a host's own editor can obey it too: read it with
+ * `useContext(RowOpenPickerContext)` and open on the rising edge.
+ */
+exports.RowOpenPickerContext = (0, react_1.createContext)(false);
+//# sourceMappingURL=rowOpenPicker.js.map

package/dist/components/form/engine/rowOpenPicker.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"rowOpenPicker.js","sourceRoot":"","sources":["../../../../src/components/form/engine/rowOpenPicker.ts"],"names":[],"mappings":";;;AAAA,+BAAsC;AAEtC;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACU,QAAA,oBAAoB,GAAG,IAAA,qBAAa,EAAU,KAAK,CAAC,CAAC"}

package/dist/components/form/engine/typeChoices.d.ts

@@ -0,0 +1,42 @@
+/**
+ * Which options offer the per-type choices ("Integer", "Text", "Hash", …) in
+ * the row's menu.
+ *
+ * A field that pins no concrete type has to give the author some way to say
+ * what kind of value they mean, and the row menu is where that lives — the
+ * alternative, a standalone *"Please select data type"* control, replaces a
+ * typable field with a pick-only one.
+ *
+ * The rule was `ui_type === 'any'`, which is one of the three ways a schema
+ * says "untyped", so the choices went missing on the other two:
+ *
+ *  - **`type: 'auto'` with no `ui_type` at all.** This is how the server
+ *    declares an assertion's Expected Value, so that field never offered them.
+ *    They appeared only inside an expression, where the OPERAND's schema does
+ *    say `ui_type: 'any'` — so the same option offered them in the Visual view
+ *    and not in the Text view, which reads as the menu losing items.
+ *  - **A host's own untyped editor.** The IDE renders Expected Value through
+ *    `test-reference`, a `ui_type` reqraft knows nothing about; the field is no
+ *    less untyped for having a custom editor.
+ *
+ * `ui_type` is asked FIRST and on its own: a schema that names a concrete
+ * editor (`ui_type: 'string'`) has pinned the field even if its storage `type`
+ * is still `auto`.
+ */
+import type { TQorusFormFieldSchema } from '@qoretechnologies/ts-toolkit';
+/**
+ * The spellings that mean "no concrete type" wherever they appear.
+ *
+ * Re-exported from the type vocabulary in `helpers/optionUiTypes`, which is
+ * where it now lives so non-component code can ask the same question.
+ */
+export declare const BuiltInAnyLikeTypes: readonly string[];
+/**
+ * Does this option leave its type up to the author?
+ *
+ * @param option the option's schema entry
+ * @param extraUiTypes host `ui_type` names that are untyped editors of their
+ * own — see `FormEngine`'s `anyLikeUiTypes`
+ */
+export declare const offersTypeChoices: (option: TQorusFormFieldSchema | undefined, extraUiTypes?: string[]) => boolean;
+//# sourceMappingURL=typeChoices.d.ts.map

package/dist/components/form/engine/typeChoices.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"typeChoices.d.ts","sourceRoot":"","sources":["../../../../src/components/form/engine/typeChoices.ts"],"names":[],"mappings":"AACA;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,8BAA8B,CAAC;AAG1E;;;;;GAKG;AACH,eAAO,MAAM,mBAAmB,EAAE,SAAS,MAAM,EAAyB,CAAC;AAE3E;;;;;;GAMG;AACH,eAAO,MAAM,iBAAiB,WACpB,qBAAqB,GAAG,SAAS,iBAC1B,MAAM,EAAE,KACtB,OAeF,CAAC"}

package/dist/components/form/engine/typeChoices.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.offersTypeChoices = exports.BuiltInAnyLikeTypes = void 0;
+var optionUiTypes_1 = require("../../../helpers/optionUiTypes");
+/**
+ * The spellings that mean "no concrete type" wherever they appear.
+ *
+ * Re-exported from the type vocabulary in `helpers/optionUiTypes`, which is
+ * where it now lives so non-component code can ask the same question.
+ */
+exports.BuiltInAnyLikeTypes = optionUiTypes_1.UNTYPED_OPTION_TYPES;
+/**
+ * Does this option leave its type up to the author?
+ *
+ * @param option the option's schema entry
+ * @param extraUiTypes host `ui_type` names that are untyped editors of their
+ * own — see `FormEngine`'s `anyLikeUiTypes`
+ */
+var offersTypeChoices = function (option, extraUiTypes) {
+    if (!option) {
+        return false;
+    }
+    var uiType = option.ui_type;
+    if (uiType) {
+        return exports.BuiltInAnyLikeTypes.includes(uiType) || !!(extraUiTypes === null || extraUiTypes === void 0 ? void 0 : extraUiTypes.includes(uiType));
+    }
+    // No `ui_type`: the storage type is the only thing that can pin the field,
+    // read as the field is rendered (`firstDeclaredType`).
+    var type = (0, optionUiTypes_1.firstDeclaredType)(option.type);
+    return type !== undefined && exports.BuiltInAnyLikeTypes.includes(type);
+};
+exports.offersTypeChoices = offersTypeChoices;
+//# sourceMappingURL=typeChoices.js.map

package/dist/components/form/engine/typeChoices.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"typeChoices.js","sourceRoot":"","sources":["../../../../src/components/form/engine/typeChoices.ts"],"names":[],"mappings":";;;AA2BA,gEAAyF;AAEzF;;;;;GAKG;AACU,QAAA,mBAAmB,GAAsB,oCAAoB,CAAC;AAE3E;;;;;;GAMG;AACI,IAAM,iBAAiB,GAAG,UAC/B,MAAyC,EACzC,YAAuB;IAEvB,IAAI,CAAC,MAAM,EAAE,CAAC;QACZ,OAAO,KAAK,CAAC;IACf,CAAC;IAED,IAAM,MAAM,GAAuB,MAAM,CAAC,OAAO,CAAC;IAElD,IAAI,MAAM,EAAE,CAAC;QACX,OAAO,2BAAmB,CAAC,QAAQ,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC,CAAA,YAAY,aAAZ,YAAY,uBAAZ,YAAY,CAAE,QAAQ,CAAC,MAAM,CAAC,CAAA,CAAC;IAClF,CAAC;IAED,2EAA2E;IAC3E,uDAAuD;IACvD,IAAM,IAAI,GAAG,IAAA,iCAAiB,EAAC,MAAM,CAAC,IAAI,CAAC,CAAC;IAC5C,OAAO,IAAI,KAAK,SAAS,IAAI,2BAAmB,CAAC,QAAQ,CAAC,IAAI,CAAC,CAAC;AAClE,CAAC,CAAC;AAlBW,QAAA,iBAAiB,qBAkB5B"}

package/dist/components/form/expressions/DpqlRendering.d.ts

@@ -0,0 +1,26 @@
+import { IReqoreFormTemplates } from '@qoretechnologies/reqore/dist/components/Textarea';
+import { IExpressionValue } from './types';
+export interface IDpqlRenderingProps {
+    /** DPQL, or a readable rendering of it, to show. */
+    text: string;
+    /** The surface's template catalogue: a reference in it reads as its name. */
+    templates?: IReqoreFormTemplates;
+    'data-testid'?: string;
+}
+/** Shows `text` as DPQL: monospace, server-coloured, references as chips. */
+export declare const DpqlRendering: ({ text, templates, "data-testid": testId }: IDpqlRenderingProps) => import("react/jsx-runtime").JSX.Element;
+export interface IExpressionRenderingProps {
+    /** The expression AST to render. */
+    expression: IExpressionValue;
+    /** The surface's template catalogue: a reference in it reads as its name. */
+    templates?: IReqoreFormTemplates;
+    'data-testid'?: string;
+}
+/**
+ * The server's readable rendering of `expression`, shown through
+ * `DpqlRendering`. It waits for the server — in the form's one waiting shape —
+ * and says so plainly if the server cannot render, rather than showing an
+ * approximation that reads like the real thing.
+ */
+export declare const ExpressionRendering: ({ expression, templates, "data-testid": testId, }: IExpressionRenderingProps) => import("react/jsx-runtime").JSX.Element;
+//# sourceMappingURL=DpqlRendering.d.ts.map

package/dist/components/form/expressions/DpqlRendering.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"DpqlRendering.d.ts","sourceRoot":"","sources":["../../../../src/components/form/expressions/DpqlRendering.tsx"],"names":[],"mappings":"AAYA,OAAO,EAAE,oBAAoB,EAAE,MAAM,mDAAmD,CAAC;AAIzF,OAAO,EAAE,gBAAgB,EAAE,MAAM,SAAS,CAAC;AAK3C,MAAM,WAAW,mBAAmB;IAClC,oDAAoD;IACpD,IAAI,EAAE,MAAM,CAAC;IACb,6EAA6E;IAC7E,SAAS,CAAC,EAAE,oBAAoB,CAAC;IACjC,aAAa,CAAC,EAAE,MAAM,CAAC;CACxB;AAED,6EAA6E;AAC7E,eAAO,MAAM,aAAa,+CAAgD,mBAAmB,4CAiB5F,CAAC;AAEF,MAAM,WAAW,yBAAyB;IACxC,oCAAoC;IACpC,UAAU,EAAE,gBAAgB,CAAC;IAC7B,6EAA6E;IAC7E,SAAS,CAAC,EAAE,oBAAoB,CAAC;IACjC,aAAa,CAAC,EAAE,MAAM,CAAC;CACxB;AAED;;;;;GAKG;AACH,eAAO,MAAM,mBAAmB,sDAI7B,yBAAyB,4CAiB3B,CAAC"}