@qoretechnologies/reqraft 0.10.65 → 0.10.66-pr.137.ga1983bf

package/dist/helpers/descriptionTooltip.js

@@ -0,0 +1,76 @@
+"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);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.descriptionTooltip = exports.describedContent = exports.useDescriptionTooltips = exports.DESCRIPTION_TOOLTIP_MAX_WIDTH = void 0;
+var react_1 = require("react");
+var markdownRendererContext_1 = require("../components/Description/markdownRendererContext");
+var useCoarsePointer_1 = require("../hooks/useCoarsePointer");
+var markdownText_1 = require("./markdownText");
+/**
+ * How wide a description's card grows: as wide as what it says, up to a readable line (about 80 characters of
+ * the card's text), and never wider than the screen. At 360px a one-sentence description broke onto two lines on
+ * any screen.
+ */
+exports.DESCRIPTION_TOOLTIP_MAX_WIDTH = 'min(560px, calc(100vw - 24px))';
+/**
+ * How this surface shows a description's card: drawn by the host's markdown renderer, and opened by a tap
+ * where there is no hover.
+ *
+ * A hover card does not open on a touch screen. Reqore opens it on `mouseenter` and closes it on any click,
+ * and a tap is both, so the card closed the moment it opened and what it says was out of a finger's reach.
+ * Where the pointer is a finger (`useCoarsePointer`, as the color field and the expression builder ask), the
+ * card opens on a tap of what it describes and closes on the next tap, there or anywhere else.
+ */
+var useDescriptionTooltips = function () {
+    var render = (0, markdownRendererContext_1.useMarkdownRenderer)();
+    var tapToOpen = (0, useCoarsePointer_1.useCoarsePointer)();
+    return (0, react_1.useMemo)(function () { return ({ render: render, tapToOpen: tapToOpen }); }, [render, tapToOpen]);
+};
+exports.useDescriptionTooltips = useDescriptionTooltips;
+/** A description drawn as a hover draws it: by the host's renderer, compact, else as its plain text. */
+var describedContent = function (description, _a) {
+    var render = _a.render;
+    return render ? render({ value: description, compact: true }) : (0, markdownText_1.plainTextNode)(description);
+};
+exports.describedContent = describedContent;
+/**
+ * A description from the server as the hover of whatever it describes: a template chip, a choice, a
+ * section of a schema.
+ *
+ * A description is markdown, written by the same author as the field descriptions and the template list
+ * this package already draws through the host's renderer (`useMarkdownRenderer`). A hover that took the
+ * same string as plain content printed its `**` and backticks at the reader, beside a list that drew them.
+ * So every hover of a description is made here, drawn by the same renderer, `compact` as a hover card is.
+ *
+ * Without a host renderer it reads as the plain text its markdown renders to - the words and the paragraph
+ * breaks, none of the marks (`markdownToPlainText`) - as the template list's rows do: reqraft draws in no dialect
+ * the host never chose, and prints no `**` either.
+ *
+ * `title` heads the card - a template's name, say. Returns the title alone when there is no description,
+ * and undefined when there is neither.
+ */
+var descriptionTooltip = function (description, _a, title) {
+    var render = _a.render, tapToOpen = _a.tapToOpen;
+    var touch = tapToOpen ? { handler: 'click' } : {};
+    if (typeof description !== 'string' || !description.trim()) {
+        // a title alone says what the thing it is on already says: nothing for a finger to open
+        return title || undefined;
+    }
+    var content = (0, exports.describedContent)(description, { render: render });
+    if (typeof content === 'string' && !title && !tapToOpen) {
+        return content;
+    }
+    return __assign(__assign(__assign({}, (title ? { title: title } : {})), { content: content, maxWidth: exports.DESCRIPTION_TOOLTIP_MAX_WIDTH }), touch);
+};
+exports.descriptionTooltip = descriptionTooltip;
+//# sourceMappingURL=descriptionTooltip.js.map

package/dist/helpers/descriptionTooltip.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"descriptionTooltip.js","sourceRoot":"","sources":["../../src/helpers/descriptionTooltip.ts"],"names":[],"mappings":";;;;;;;;;;;;;;AAEA,+BAAgC;AAChC,6FAG2D;AAC3D,8DAA6D;AAC7D,+CAA+C;AAE/C;;;;GAIG;AACU,QAAA,6BAA6B,GAAG,gCAAgC,CAAC;AAU9E;;;;;;;;GAQG;AACI,IAAM,sBAAsB,GAAG;IACpC,IAAM,MAAM,GAAG,IAAA,6CAAmB,GAAE,CAAC;IACrC,IAAM,SAAS,GAAG,IAAA,mCAAgB,GAAE,CAAC;IACrC,OAAO,IAAA,eAAO,EAAC,cAAM,OAAA,CAAC,EAAE,MAAM,QAAA,EAAE,SAAS,WAAA,EAAE,CAAC,EAAvB,CAAuB,EAAE,CAAC,MAAM,EAAE,SAAS,CAAC,CAAC,CAAC;AACrE,CAAC,CAAC;AAJW,QAAA,sBAAsB,0BAIjC;AAEF,wGAAwG;AACjG,IAAM,gBAAgB,GAAG,UAAC,WAAmB,EAAE,EAAsC;QAApC,MAAM,YAAA;IAC5D,OAAA,MAAM,CAAC,CAAC,CAAC,MAAM,CAAC,EAAE,KAAK,EAAE,WAAW,EAAE,OAAO,EAAE,IAAI,EAAE,CAAC,CAAC,CAAC,CAAC,IAAA,4BAAa,EAAC,WAAW,CAAC;AAAnF,CAAmF,CAAC;AADzE,QAAA,gBAAgB,oBACyD;AAEtF;;;;;;;;;;;;;;;GAeG;AACI,IAAM,kBAAkB,GAAG,UAChC,WAAoB,EACpB,EAAiD,EACjD,KAAc;QADZ,MAAM,YAAA,EAAE,SAAS,eAAA;IAGnB,IAAM,KAAK,GAA4B,SAAS,CAAC,CAAC,CAAC,EAAE,OAAO,EAAE,OAAO,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC;IAC7E,IAAI,OAAO,WAAW,KAAK,QAAQ,IAAI,CAAC,WAAW,CAAC,IAAI,EAAE,EAAE,CAAC;QAC3D,wFAAwF;QACxF,OAAO,KAAK,IAAI,SAAS,CAAC;IAC5B,CAAC;IACD,IAAM,OAAO,GAAG,IAAA,wBAAgB,EAAC,WAAW,EAAE,EAAE,MAAM,QAAA,EAAE,CAA8B,CAAC;IACvF,IAAI,OAAO,OAAO,KAAK,QAAQ,IAAI,CAAC,KAAK,IAAI,CAAC,SAAS,EAAE,CAAC;QACxD,OAAO,OAAO,CAAC;IACjB,CAAC;IACD,sCACK,CAAC,KAAK,CAAC,CAAC,CAAC,EAAE,KAAK,OAAA,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC,KAC3B,OAAO,SAAA,EACP,QAAQ,EAAE,qCAA6B,KACpC,KAAK,EACR;AACJ,CAAC,CAAC;AApBW,QAAA,kBAAkB,sBAoB7B"}

package/dist/helpers/domProps.d.ts

@@ -0,0 +1,5 @@
+/** Whether a prop is one any HTML element takes: a global attribute, `aria-*`, `data-*` or an event handler. */
+export declare const isHtmlElementProp: (name: string) => boolean;
+/** The props any HTML element takes, and nothing else; see `isHtmlElementProp`. */
+export declare const htmlElementProps: <T extends object>(props: T) => Partial<T>;
+//# sourceMappingURL=domProps.d.ts.map

package/dist/helpers/domProps.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"domProps.d.ts","sourceRoot":"","sources":["../../src/helpers/domProps.ts"],"names":[],"mappings":"AAgCA,gHAAgH;AAChH,eAAO,MAAM,iBAAiB,SAAU,MAAM,KAAG,OACmC,CAAC;AAErF,mFAAmF;AACnF,eAAO,MAAM,gBAAgB,4BAA6B,CAAC,KAAG,QAAQ,CAAC,CAGtD,CAAC"}

package/dist/helpers/domProps.js

@@ -0,0 +1,47 @@
+"use strict";
+// Copyright 2026 Qore Technologies, s.r.o.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.htmlElementProps = exports.isHtmlElementProp = void 0;
+/**
+ * The attributes any HTML element takes, beside `aria-*`, `data-*` and event handlers (qorus#646).
+ *
+ * A component that renders a plain element and takes the rest of its props for it passes that element only these.
+ * What else it is handed is not an attribute: a Reqore control group hands each component in it its layout props
+ * (`fluid`, `spaceBetween`, `size`, `intent`, `customTheme`, ...), and spread onto an element React warns of each
+ * ("Received `true` for a non-boolean attribute `fluid`") and writes the rest into the DOM.
+ */
+var GLOBAL_ATTRIBUTES = new Set([
+    'id',
+    'className',
+    'style',
+    'title',
+    'role',
+    'tabIndex',
+    'lang',
+    'dir',
+    'hidden',
+    'translate',
+    'draggable',
+    'slot',
+    'accessKey',
+    'autoFocus',
+    'inert',
+    'contentEditable',
+    'spellCheck',
+    'suppressContentEditableWarning',
+    'suppressHydrationWarning',
+]);
+/** Whether a prop is one any HTML element takes: a global attribute, `aria-*`, `data-*` or an event handler. */
+var isHtmlElementProp = function (name) {
+    return GLOBAL_ATTRIBUTES.has(name) || /^(aria|data)-/.test(name) || /^on[A-Z]/.test(name);
+};
+exports.isHtmlElementProp = isHtmlElementProp;
+/** The props any HTML element takes, and nothing else; see `isHtmlElementProp`. */
+var htmlElementProps = function (props) {
+    return Object.fromEntries(Object.entries(props).filter(function (_a) {
+        var name = _a[0];
+        return (0, exports.isHtmlElementProp)(name);
+    }));
+};
+exports.htmlElementProps = htmlElementProps;
+//# sourceMappingURL=domProps.js.map

package/dist/helpers/domProps.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"domProps.js","sourceRoot":"","sources":["../../src/helpers/domProps.ts"],"names":[],"mappings":";AAAA,2CAA2C;;;AAE3C;;;;;;;GAOG;AACH,IAAM,iBAAiB,GAAG,IAAI,GAAG,CAAC;IAChC,IAAI;IACJ,WAAW;IACX,OAAO;IACP,OAAO;IACP,MAAM;IACN,UAAU;IACV,MAAM;IACN,KAAK;IACL,QAAQ;IACR,WAAW;IACX,WAAW;IACX,MAAM;IACN,WAAW;IACX,WAAW;IACX,OAAO;IACP,iBAAiB;IACjB,YAAY;IACZ,gCAAgC;IAChC,0BAA0B;CAC3B,CAAC,CAAC;AAEH,gHAAgH;AACzG,IAAM,iBAAiB,GAAG,UAAC,IAAY;IAC5C,OAAA,iBAAiB,CAAC,GAAG,CAAC,IAAI,CAAC,IAAI,eAAe,CAAC,IAAI,CAAC,IAAI,CAAC,IAAI,UAAU,CAAC,IAAI,CAAC,IAAI,CAAC;AAAlF,CAAkF,CAAC;AADxE,QAAA,iBAAiB,qBACuD;AAErF,mFAAmF;AAC5E,IAAM,gBAAgB,GAAG,UAAmB,KAAQ;IACzD,OAAA,MAAM,CAAC,WAAW,CAChB,MAAM,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC,MAAM,CAAC,UAAC,EAAM;YAAL,IAAI,QAAA;QAAM,OAAA,IAAA,yBAAiB,EAAC,IAAI,CAAC;IAAvB,CAAuB,CAAC,CACpD;AAFf,CAEe,CAAC;AAHL,QAAA,gBAAgB,oBAGX"}

package/dist/helpers/expressions.d.ts

@@ -1,8 +1,21 @@
 import { IExpression, IExpressionSchema, IExpressionSchemaArg } from '../components/form/expressions/types';
 import { IQorusTypeObject } from '../hooks/useQorusTypes';
-export declare const getArgumentType: (expressions: IExpressionSchema[], arg?: IExpression, schema?: IExpressionSchemaArg) => string;
-export declare const argumentMatchesType: (expressions: IExpressionSchema[], arg: IExpression | undefined, schema: IExpressionSchemaArg) => boolean;
-export declare const areQorusTypesCompatible: (mainType: string | string[], checkType: string | string[], fallbackTypes?: IQorusTypeObject[]) => boolean;
+/**
+ * The UI type of an argument: a value's own type, or, for an expression, the
+ * type the server gave for it (`useExpressionType`) — an expression's type is
+ * never worked out here, so it is the same as everywhere else in Qorus
+ * (qoretechnologies/qorus#713). `any`, which nothing is judged by, until the
+ * server has given it.
+ */
+export declare const getArgumentType: (_expressions: IExpressionSchema[], arg?: IExpression, schema?: IExpressionSchemaArg) => string;
+export declare const argumentMatchesType: (expressions: IExpressionSchema[], arg: IExpression | undefined, schema: IExpressionSchemaArg, types?: IQorusTypeObject[]) => boolean;
+/**
+ * Whether a value of `checkType` fits a place of `mainType`, by the type catalogue `types`: the server's answer
+ * (`useQorusTypes().value`, or `getQorusTypes()` outside a component), reqraft's copy until it answers. A type the
+ * catalogue does not list is its base type, `mainBaseType` for the place's and `checkBaseType` for the value's
+ * (`qorusTypeEntry`).
+ */
+export declare const areQorusTypesCompatible: (mainType: string | string[], checkType: string | string[], types?: IQorusTypeObject[], mainBaseType?: string, checkBaseType?: string) => boolean;
 /**
  * Whether a type is text, a date or a time: what a condition cannot be. A condition is evaluated by its
  * truthiness, so a number (0 or not), a list or hash (empty or not), binary data and an untyped result
@@ -10,8 +23,106 @@ export declare const areQorusTypesCompatible: (mainType: string | string[], chec
  * instead (`@status == "open"`, `@note != ""`). The Qorus server applies the same rule.
  */
 export declare const isTextOrDateType: (type: string) => boolean;
-/** Whether a place takes a condition: its result must be true or false (`bool`, or a list of only that). */
+/**
+ * Whether a place takes a condition: its result must be true or false (`bool`, optional or soft, or a list of
+ * only that).
+ */
 export declare const isConditionType: (returnType: string | string[] | undefined) => boolean;
+/**
+ * What an editor says of a condition that gives this type (qorus#646): nothing for true or false or a type it
+ * cannot tell (`any`, `auto`); an error for text, a date or a time, which do not say plainly what is meant;
+ * and a warning for any other (a number, a list, a hash), which the condition reads as true unless it is
+ * zero or empty - accepted, as the Qorus server accepts it, but said, because it is seldom what was meant.
+ * qorus-ide says the same of its own condition editors.
+ */
+export declare const conditionVerdict: (type: string | undefined) => 'error' | 'warning' | undefined;
+/**
+ * Whether a field is a condition: its schema's `metadata.condition`, the mark a host sets on the options that
+ * are conditions (a Qog transition's value, a built-in if's value, a while or for block's condition). The
+ * schema's own `type` cannot say it: a value of type bool is not a condition.
+ */
+export declare const isConditionOption: (field: {
+    metadata?: Record<string, unknown>;
+} | undefined) => boolean;
+/** A type as a condition reads it: without the optional mark, `soft`, or what a list or hash holds. */
+export declare const conditionBaseType: (type: string | undefined) => string;
+/**
+ * What is said of a condition that gives text, a date or a time (NOT_A_CONDITION): what it gives, and how to make
+ * it one, with an example for its type. `typeInSentence` is the type named inside a sentence - its sentence form
+ * ("text"), as `qorusTypeSentenceForm` gives it - and `baseType` the type it is (`string`, `date`, `time`): the
+ * example follows it. These are the server's words: a fallback for when it said none, never a second wording of
+ * them. With no type to name, the sentence names none: "The condition must evaluate to true or false. …".
+ */
+export declare const conditionErrorText: (typeInSentence: string | undefined, baseType: string | undefined) => string;
+/**
+ * What the expression builder says of an expression whose result does not fit its place: what it gives, what the
+ * place takes, and what to do. `gives` and `takes` name the types inside the sentence - their sentence forms ("a
+ * whole number"), as `qorusTypeSentenceForm` gives them, `takes` joined with "or" where a place takes more than
+ * one - and `gives` is undefined for an expression that gives nothing yet, `takes` for a place whose type is not
+ * known: the sentence then says what it gives without naming a type it cannot name (qorus#646).
+ */
+export declare const expressionTypeMismatchText: (gives: string | undefined, takes: string | undefined) => string;
+/**
+ * What the builder's conversion list says of an argument it converts: from what to what. `from` and `to` name the
+ * types inside the sentence - their sentence forms, as `qorusTypeSentenceForm` gives them - and either is undefined
+ * where the type is not known; the sentence then names only the other, or neither (qorus#646).
+ */
+export declare const conversionText: (from: string | undefined, to: string | undefined) => string;
+/**
+ * What is said of a condition that gives a number, a list, a hash or a type that is not known
+ * (CONDITION_BY_TRUTHINESS): how Qorus reads it, and how to say it explicitly, by the type it gives - named by its
+ * sentence form ("a whole number", "key-value pairs (a hash)"), as the server names it
+ * (`QonsoleDesignI18n::conditionByTruthinessText`, qorus 04e6c502f). These are the server's words: a fallback for
+ * when it said none.
+ */
+export declare const conditionByTruthinessText: (type: string | undefined) => string;
+/** The operators whose every part is read as true or false by its value: AND, OR and NOT. */
+export declare const LOGICAL_OPERATORS: readonly ["&&", "||", "!"];
+/** Whether an expression is an AND, an OR or a NOT. */
+export declare const isLogicalOperation: (expression: IExpression | undefined) => boolean;
+/** How the server reads a part of a condition (`dpql/parse` with `condition: true`, qorus#646). */
+export type TConditionReading = 'condition' | 'truthiness' | 'not_a_condition' | 'unknown';
+/** A part of an AND, an OR or a NOT in a condition: the type it gives and how it is read. */
+export interface IConditionPart {
+    type: string;
+    reading: TConditionReading;
+    /** What the server says of it, in its words, when it says anything. */
+    message?: string;
+}
+/**
+ * What the server says of a whole condition, in its words: the first condition diagnostic, when the whole
+ * expression's type (`inferredType`) makes it one the server says something of and the diagnostic is that kind.
+ * Undefined when it says nothing of the whole - true or false, a type it cannot tell, or diagnostics that do not
+ * line up.
+ */
+export declare const conditionWholeMessage: (inferredType: string | undefined, diagnostics: Array<{
+    code?: string | number;
+    message: string;
+}>) => string | undefined;
+/**
+ * The parts the server judged, each with what it said of it.
+ *
+ * The server says it in the diagnostics (NOT_A_CONDITION, CONDITION_BY_TRUTHINESS), in the order it judged:
+ * the whole expression first, then its parts - one for each that is not true or false, all over the whole
+ * text. The whole's own reading is the one its type gives (`inferredType`); the answer's `condition_reading`
+ * is the worst of all of them. A part keeps no words when the diagnostics do not line up with the readings.
+ */
+export declare const conditionPartsWithMessages: (parts: IConditionPart[] | undefined, inferredType: string | undefined, diagnostics: Array<{
+    code?: string | number;
+    message: string;
+}>) => IConditionPart[] | undefined;
+/**
+ * Where each part the server judged is drawn, by the path of its card in the expression (the builder's
+ * `path`; `''` for the expression itself).
+ *
+ * The server reads each part of `&&`, `||` and `!` as a condition (qorus#646) and answers `parts` in its own
+ * walk order: the operands of the expression's logical operator, left to right, a nested `&&`, `||` or `!`
+ * standing for its own parts. A part of an AND or an OR has its own card; the part a NOT reads is drawn on
+ * the NOT's card. An answer whose parts are not this expression's (a stale one, or none) places nothing.
+ */
+export declare const conditionPartCards: (expression: IExpression | undefined, parts: IConditionPart[] | undefined) => Record<string, IConditionPart>;
+/** What is said of a part of a condition: nothing when it is true or false or cannot be told. */
+export declare const conditionPartVerdict: (part: IConditionPart | undefined) => 'error' | 'warning' | undefined;
 /**
  * Whether an operation is offered where its result must be of `returnType`: a condition (`bool`) is
  * built from the operations whose result decides it, which is any result but text, a date or a time.

package/dist/helpers/expressions.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"expressions.d.ts","sourceRoot":"","sources":["../../src/helpers/expressions.ts"],"names":[],"mappings":"AAMA,OAAO,EACL,WAAW,EACX,iBAAiB,EACjB,oBAAoB,EACrB,MAAM,sCAAsC,CAAC;AAC9C,OAAO,EAAoC,gBAAgB,EAAE,MAAM,wBAAwB,CAAC;AAE5F,eAAO,MAAM,eAAe,gBACb,iBAAiB,EAAE,QAC1B,WAAW,WACR,oBAAoB,WAS9B,CAAC;AAEF,eAAO,MAAM,mBAAmB,gBACjB,iBAAiB,EAAE,OAC3B,WAAW,GAAG,SAAS,UACpB,oBAAoB,YAgB7B,CAAC;AAgBF,eAAO,MAAM,uBAAuB,aACxB,MAAM,GAAG,MAAM,EAAE,aAChB,MAAM,GAAG,MAAM,EAAE,kBACZ,gBAAgB,EAAE,KACjC,OAmCF,CAAC;AAEF;;;;;GAKG;AACH,eAAO,MAAM,gBAAgB,SAAU,MAAM,KAAG,OACoC,CAAC;AAErF,4GAA4G;AAC5G,eAAO,MAAM,eAAe,eAAgB,MAAM,GAAG,MAAM,EAAE,GAAG,SAAS,KAAG,OAG3E,CAAC;AAEF;;;;;;;;GAQG;AACH,eAAO,MAAM,wBAAwB,eACvB,MAAM,GAAG,MAAM,EAAE,GAAG,SAAS,cAC7B;IAAE,cAAc,CAAC,EAAE,MAAM,CAAC;IAAC,qBAAqB,CAAC,EAAE,OAAO,CAAA;CAAE,KACvE,OASF,CAAC"}
+{"version":3,"file":"expressions.d.ts","sourceRoot":"","sources":["../../src/helpers/expressions.ts"],"names":[],"mappings":"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"}

package/dist/helpers/expressions.js

@@ -1,25 +1,46 @@
 "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);
+};
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.expressionFitsReturnType = exports.isConditionType = exports.isTextOrDateType = exports.areQorusTypesCompatible = exports.argumentMatchesType = exports.getArgumentType = void 0;
+exports.expressionFitsReturnType = exports.conditionPartVerdict = exports.conditionPartCards = exports.conditionPartsWithMessages = exports.conditionWholeMessage = exports.isLogicalOperation = exports.LOGICAL_OPERATORS = exports.conditionByTruthinessText = exports.conversionText = exports.expressionTypeMismatchText = exports.conditionErrorText = exports.conditionBaseType = exports.isConditionOption = exports.conditionVerdict = exports.isConditionType = exports.isTextOrDateType = exports.areQorusTypesCompatible = exports.argumentMatchesType = exports.getArgumentType = void 0;
 // Copyright 2026 Qore Technologies, s.r.o.
-// Expression / type-compatibility helpers — ported verbatim from qorus-ide
+// Expression / type-compatibility helpers — ported from qorus-ide
 // (`src/helpers/expressions.ts` + `areQorusTypesCompatible` from
 // `src/helpers/functions.tsx`), import paths adapted to reqraft. Used by the
 // ported ExpressionBuilder.
 var lodash_1 = require("lodash");
+var useExpressionType_1 = require("../components/form/expressions/useExpressionType");
 var useQorusTypes_1 = require("../hooks/useQorusTypes");
-var getArgumentType = function (expressions, arg, schema) {
-    var _a;
+var qorusTypeCatalogue_1 = require("./qorusTypeCatalogue");
+/**
+ * The UI type of an argument: a value's own type, or, for an expression, the
+ * type the server gave for it (`useExpressionType`) — an expression's type is
+ * never worked out here, so it is the same as everywhere else in Qorus
+ * (qoretechnologies/qorus#713). `any`, which nothing is judged by, until the
+ * server has given it.
+ */
+var getArgumentType = function (_expressions, arg, schema) {
+    var _a, _b;
     if (arg === null || arg === void 0 ? void 0 : arg.is_expression) {
-        return (_a = expressions === null || expressions === void 0 ? void 0 : expressions.find(function (exp) { var _a; return exp.name === ((_a = arg.value) === null || _a === void 0 ? void 0 : _a.exp); })) === null || _a === void 0 ? void 0 : _a.ui_return_type;
+        return (_b = (_a = (0, useExpressionType_1.getCachedExpressionType)(arg.value)) === null || _a === void 0 ? void 0 : _a.ui_type) !== null && _b !== void 0 ? _b : 'any';
     }
     return (arg === null || arg === void 0 ? void 0 : arg.type) || (schema === null || schema === void 0 ? void 0 : schema.ui_type);
 };
 exports.getArgumentType = getArgumentType;
-var argumentMatchesType = function (expressions, arg, schema) {
+var argumentMatchesType = function (expressions, arg, schema, types) {
     var _a;
-    var types = (0, useQorusTypes_1.getQorusTypes)();
-    var acceptedTypes = types.find(function (type) { return type.name === schema.ui_type; });
+    if (types === void 0) { types = (0, useQorusTypes_1.getQorusTypes)(); }
+    // a type the catalogue does not list is its base type (`qorusTypeEntry`)
+    var acceptedTypes = (0, qorusTypeCatalogue_1.qorusTypeEntry)(types, schema.ui_type, schema.base_type);
     var argType = (0, exports.getArgumentType)(expressions, arg, schema);
     if (!acceptedTypes) {
         return true;
@@ -41,49 +62,56 @@ exports.argumentMatchesType = argumentMatchesType;
  * template from it, and the picker offered a group header with nothing under
  * it. The field was not "a field with no templates" — it was a field whose
  * templates had all been filtered away by a name mismatch.
+ *
+ * Qore's other names for a type (`integer`, `boolean`) are the catalogue's name for it too: the server's catalogue
+ * lists and converts each type by one name only (qorus#646).
  */
-var normalizeAnyLikeTypeName = function (name) { return (name === 'auto' ? 'any' : name); };
-var areQorusTypesCompatible = function (mainType, checkType, fallbackTypes) {
+var normalizeAnyLikeTypeName = function (name) {
+    return name === 'auto' ? 'any' : (0, qorusTypeCatalogue_1.catalogueTypeName)(name);
+};
+/**
+ * Whether a value of `checkType` fits a place of `mainType`, by the type catalogue `types`: the server's answer
+ * (`useQorusTypes().value`, or `getQorusTypes()` outside a component), reqraft's copy until it answers. A type the
+ * catalogue does not list is its base type, `mainBaseType` for the place's and `checkBaseType` for the value's
+ * (`qorusTypeEntry`).
+ */
+var areQorusTypesCompatible = function (mainType, checkType, types, mainBaseType, checkBaseType) {
     var _a, _b;
-    var types = (0, useQorusTypes_1.getQorusTypes)() || fallbackTypes || useQorusTypes_1.defaultQorusTypes;
+    if (types === void 0) { types = (0, useQorusTypes_1.getQorusTypes)(); }
     var mainTypes = ((0, lodash_1.isArray)(mainType) ? mainType : [mainType]).map(normalizeAnyLikeTypeName);
-    var checkTypes = ((0, lodash_1.isArray)(checkType) ? checkType : [checkType]).map(normalizeAnyLikeTypeName);
-    var _loop_1 = function (main) {
-        // Get the type object from the types
-        var mainTypeObject = types.find(function (type) { return type.name === main; });
+    // a value's type by the name the catalogue lists it under (`*int`, `softint`: `int`), else by its base type's
+    var checkTypes = ((0, lodash_1.isArray)(checkType) ? checkType : [checkType]).map(function (check) { var _a, _b; return (_b = (_a = (0, qorusTypeCatalogue_1.qorusTypeEntry)(types, check, checkBaseType)) === null || _a === void 0 ? void 0 : _a.name) !== null && _b !== void 0 ? _b : normalizeAnyLikeTypeName(check); });
+    // Get each of the main types from the types list
+    for (var _i = 0, mainTypes_1 = mainTypes; _i < mainTypes_1.length; _i++) {
+        var main = mainTypes_1[_i];
+        // its entry: by its own name, an optional, soft or complex form of one, else its base type (`qorusTypeEntry`)
+        var mainTypeObject = (0, qorusTypeCatalogue_1.qorusTypeEntry)(types, main, mainBaseType);
         // If the main object does not exist
         if (!mainTypeObject) {
-            return { value: false };
+            return false;
         }
         // If the main type includes "any" it's automatically compatible
         if ((_a = mainTypeObject.exact_match) === null || _a === void 0 ? void 0 : _a.includes('any')) {
-            return { value: true };
+            return true;
         }
         // Check if any of the check types are in the main types accepted types
         for (var _c = 0, checkTypes_1 = checkTypes; _c < checkTypes_1.length; _c++) {
             var check = checkTypes_1[_c];
             if ((_b = mainTypeObject.exact_match) === null || _b === void 0 ? void 0 : _b.includes(check)) {
-                return { value: true };
+                return true;
             }
         }
         // If the main type includes "any" it's automatically compatible
         if (mainTypeObject.types_accepted.includes('any')) {
-            return { value: true };
+            return true;
         }
         // Check if any of the check types are in the main types accepted types
         for (var _d = 0, checkTypes_2 = checkTypes; _d < checkTypes_2.length; _d++) {
             var check = checkTypes_2[_d];
             if (mainTypeObject.types_accepted.includes(check)) {
-                return { value: true };
+                return true;
             }
         }
-    };
-    // Get each of the main types from the types list
-    for (var _i = 0, mainTypes_1 = mainTypes; _i < mainTypes_1.length; _i++) {
-        var main = mainTypes_1[_i];
-        var state_1 = _loop_1(main);
-        if (typeof state_1 === "object")
-            return state_1.value;
     }
     // If none of the types are compatible return false
     return false;
@@ -99,12 +127,202 @@ var isTextOrDateType = function (type) {
     return /^(string|richtext|date|time)$/.test(type.replace(/^\*/, '').replace(/^soft/, ''));
 };
 exports.isTextOrDateType = isTextOrDateType;
-/** Whether a place takes a condition: its result must be true or false (`bool`, or a list of only that). */
+/**
+ * Whether a place takes a condition: its result must be true or false (`bool`, optional or soft, or a list of
+ * only that).
+ */
 var isConditionType = function (returnType) {
     var types = (0, lodash_1.isArray)(returnType) ? returnType : returnType ? [returnType] : [];
-    return types.length > 0 && types.every(function (type) { return /^\*?(bool|boolean)$/.test(type); });
+    return types.length > 0 && types.every(function (type) { return /^\*?(soft)?(bool|boolean)$/.test(type); });
 };
 exports.isConditionType = isConditionType;
+/**
+ * What an editor says of a condition that gives this type (qorus#646): nothing for true or false or a type it
+ * cannot tell (`any`, `auto`); an error for text, a date or a time, which do not say plainly what is meant;
+ * and a warning for any other (a number, a list, a hash), which the condition reads as true unless it is
+ * zero or empty - accepted, as the Qorus server accepts it, but said, because it is seldom what was meant.
+ * qorus-ide says the same of its own condition editors.
+ */
+var conditionVerdict = function (type) {
+    if (!type) {
+        return undefined;
+    }
+    var base = type.replace(/^\*/, '').replace(/^soft/, '').replace(/<.*$/, '');
+    if (!base || /^(bool|boolean|any|auto)$/.test(base)) {
+        return undefined;
+    }
+    return (0, exports.isTextOrDateType)(base) ? 'error' : 'warning';
+};
+exports.conditionVerdict = conditionVerdict;
+/**
+ * Whether a field is a condition: its schema's `metadata.condition`, the mark a host sets on the options that
+ * are conditions (a Qog transition's value, a built-in if's value, a while or for block's condition). The
+ * schema's own `type` cannot say it: a value of type bool is not a condition.
+ */
+var isConditionOption = function (field) { var _a; return ((_a = field === null || field === void 0 ? void 0 : field.metadata) === null || _a === void 0 ? void 0 : _a.condition) === true; };
+exports.isConditionOption = isConditionOption;
+/** A type as a condition reads it: without the optional mark, `soft`, or what a list or hash holds. */
+var conditionBaseType = function (type) {
+    return (type !== null && type !== void 0 ? type : '').replace(/^\*/, '').replace(/^soft/, '').replace(/<.*$/, '');
+};
+exports.conditionBaseType = conditionBaseType;
+/** How a condition that gives this base type is made one: compare the value (qorus#646, as the server says). */
+var conditionExample = function (baseType) {
+    return baseType === 'date' ? '@shipped_on > @ordered_on'
+        : baseType === 'time' ? '@starts_at < @ends_at'
+            : '@status == "open"';
+};
+/**
+ * What is said of a condition that gives text, a date or a time (NOT_A_CONDITION): what it gives, and how to make
+ * it one, with an example for its type. `typeInSentence` is the type named inside a sentence - its sentence form
+ * ("text"), as `qorusTypeSentenceForm` gives it - and `baseType` the type it is (`string`, `date`, `time`): the
+ * example follows it. These are the server's words: a fallback for when it said none, never a second wording of
+ * them. With no type to name, the sentence names none: "The condition must evaluate to true or false. …".
+ */
+var conditionErrorText = function (typeInSentence, baseType) {
+    return "".concat(typeInSentence ? "The condition evaluates to ".concat(typeInSentence, ", but it") : 'The condition', " must evaluate to true or false. Compare the value instead, for example ").concat(conditionExample((0, exports.conditionBaseType)(baseType)), ".");
+};
+exports.conditionErrorText = conditionErrorText;
+/**
+ * What the expression builder says of an expression whose result does not fit its place: what it gives, what the
+ * place takes, and what to do. `gives` and `takes` name the types inside the sentence - their sentence forms ("a
+ * whole number"), as `qorusTypeSentenceForm` gives them, `takes` joined with "or" where a place takes more than
+ * one - and `gives` is undefined for an expression that gives nothing yet, `takes` for a place whose type is not
+ * known: the sentence then says what it gives without naming a type it cannot name (qorus#646).
+ */
+var expressionTypeMismatchText = function (gives, takes) {
+    return takes ?
+        "This expression gives ".concat(gives !== null && gives !== void 0 ? gives : 'nothing', ", but this field takes ").concat(takes, ". Choose an expression that gives ").concat(takes, ", or put this one inside an expression that converts it.")
+        : "This expression gives ".concat(gives !== null && gives !== void 0 ? gives : 'nothing', ", which this field does not take. Choose another expression, or put this one inside an expression that converts it.");
+};
+exports.expressionTypeMismatchText = expressionTypeMismatchText;
+/**
+ * What the builder's conversion list says of an argument it converts: from what to what. `from` and `to` name the
+ * types inside the sentence - their sentence forms, as `qorusTypeSentenceForm` gives them - and either is undefined
+ * where the type is not known; the sentence then names only the other, or neither (qorus#646).
+ */
+var conversionText = function (from, to) {
+    return "Converted".concat(from ? " from ".concat(from) : '').concat(to ? " to ".concat(to) : '');
+};
+exports.conversionText = conversionText;
+/**
+ * What is said of a condition that gives a number, a list, a hash or a type that is not known
+ * (CONDITION_BY_TRUTHINESS): how Qorus reads it, and how to say it explicitly, by the type it gives - named by its
+ * sentence form ("a whole number", "key-value pairs (a hash)"), as the server names it
+ * (`QonsoleDesignI18n::conditionByTruthinessText`, qorus 04e6c502f). These are the server's words: a fallback for
+ * when it said none.
+ */
+var conditionByTruthinessText = function (type) {
+    var base = (0, exports.conditionBaseType)(type);
+    var named = (0, qorusTypeCatalogue_1.qorusTypeSentenceForm)((0, useQorusTypes_1.getQorusTypes)(), base);
+    if (/^(int|integer|float|number)$/.test(base)) {
+        return "The condition evaluates to ".concat(named, "; Qorus treats it as true unless it is 0. To make that explicit, compare it, for example @count > 0.");
+    }
+    if (base === 'list') {
+        return "The condition evaluates to ".concat(named, "; Qorus treats it as true unless it is empty. To make that explicit, compare its size, for example size(@items) > 0.");
+    }
+    if (base === 'hash') {
+        return "The condition evaluates to ".concat(named, "; Qorus treats it as true unless it holds no pairs. To make that explicit, compare its size, for example size(@details) > 0.");
+    }
+    return "The condition's value is not true or false; Qorus treats it as true unless it is 0 or empty. To make that explicit, compare it, for example @count > 0.";
+};
+exports.conditionByTruthinessText = conditionByTruthinessText;
+/** The operators whose every part is read as true or false by its value: AND, OR and NOT. */
+exports.LOGICAL_OPERATORS = ['&&', '||', '!'];
+/** Whether an expression is an AND, an OR or a NOT. */
+var isLogicalOperation = function (expression) {
+    var _a;
+    return !!(expression === null || expression === void 0 ? void 0 : expression.is_expression) &&
+        exports.LOGICAL_OPERATORS.includes((_a = expression.value) === null || _a === void 0 ? void 0 : _a.exp);
+};
+exports.isLogicalOperation = isLogicalOperation;
+/** The server's code for what it says of a condition read as this verdict. */
+var CONDITION_CODE_OF_VERDICT = { error: 'NOT_A_CONDITION', warning: 'CONDITION_BY_TRUTHINESS' };
+/**
+ * What the server says of a whole condition, in its words: the first condition diagnostic, when the whole
+ * expression's type (`inferredType`) makes it one the server says something of and the diagnostic is that kind.
+ * Undefined when it says nothing of the whole - true or false, a type it cannot tell, or diagnostics that do not
+ * line up.
+ */
+var conditionWholeMessage = function (inferredType, diagnostics) {
+    var verdict = (0, exports.conditionVerdict)(inferredType);
+    if (!verdict) {
+        return undefined;
+    }
+    var first = diagnostics.find(function (d) { return d.code === 'NOT_A_CONDITION' || d.code === 'CONDITION_BY_TRUTHINESS'; });
+    return (first === null || first === void 0 ? void 0 : first.code) === CONDITION_CODE_OF_VERDICT[verdict] ? first.message : undefined;
+};
+exports.conditionWholeMessage = conditionWholeMessage;
+/**
+ * The parts the server judged, each with what it said of it.
+ *
+ * The server says it in the diagnostics (NOT_A_CONDITION, CONDITION_BY_TRUTHINESS), in the order it judged:
+ * the whole expression first, then its parts - one for each that is not true or false, all over the whole
+ * text. The whole's own reading is the one its type gives (`inferredType`); the answer's `condition_reading`
+ * is the worst of all of them. A part keeps no words when the diagnostics do not line up with the readings.
+ */
+var conditionPartsWithMessages = function (parts, inferredType, diagnostics) {
+    if (!parts) {
+        return undefined;
+    }
+    var said = diagnostics.filter(function (d) { return d.code === 'NOT_A_CONDITION' || d.code === 'CONDITION_BY_TRUTHINESS'; });
+    var codeOf = function (reading) {
+        return reading === 'not_a_condition' ? 'NOT_A_CONDITION'
+            : reading === 'truthiness' ? 'CONDITION_BY_TRUTHINESS'
+                : undefined;
+    };
+    // the whole's diagnostic comes first, when its type gives it one (`conditionWholeMessage`)
+    var rest = (0, exports.conditionVerdict)(inferredType) ? said.slice(1) : said;
+    var partCodes = parts.map(function (part) { return codeOf(part.reading); }).filter(Boolean);
+    if (rest.length !== partCodes.length || rest.some(function (d, index) { return d.code !== partCodes[index]; })) {
+        return parts;
+    }
+    var next = 0;
+    return parts.map(function (part) {
+        return codeOf(part.reading) ? __assign(__assign({}, part), { message: rest[next++].message }) : part;
+    });
+};
+exports.conditionPartsWithMessages = conditionPartsWithMessages;
+/**
+ * Where each part the server judged is drawn, by the path of its card in the expression (the builder's
+ * `path`; `''` for the expression itself).
+ *
+ * The server reads each part of `&&`, `||` and `!` as a condition (qorus#646) and answers `parts` in its own
+ * walk order: the operands of the expression's logical operator, left to right, a nested `&&`, `||` or `!`
+ * standing for its own parts. A part of an AND or an OR has its own card; the part a NOT reads is drawn on
+ * the NOT's card. An answer whose parts are not this expression's (a stale one, or none) places nothing.
+ */
+var conditionPartCards = function (expression, parts) {
+    var cards = [];
+    var walk = function (node, path) {
+        var _a, _b;
+        ((_b = (_a = node.value) === null || _a === void 0 ? void 0 : _a.args) !== null && _b !== void 0 ? _b : []).forEach(function (arg, index) {
+            var _a;
+            var argPath = "".concat(path ? "".concat(path, ".") : '', "value.args.").concat(index);
+            if ((0, exports.isLogicalOperation)(arg)) {
+                walk(arg, argPath);
+            }
+            else {
+                cards.push(((_a = node.value) === null || _a === void 0 ? void 0 : _a.exp) === '!' ? path : argPath);
+            }
+        });
+    };
+    if (expression && (0, exports.isLogicalOperation)(expression)) {
+        walk(expression, '');
+    }
+    if (!parts || parts.length !== cards.length) {
+        return {};
+    }
+    return Object.fromEntries(cards.map(function (card, index) { return [card, parts[index]]; }));
+};
+exports.conditionPartCards = conditionPartCards;
+/** What is said of a part of a condition: nothing when it is true or false or cannot be told. */
+var conditionPartVerdict = function (part) {
+    return (part === null || part === void 0 ? void 0 : part.reading) === 'not_a_condition' ? 'error'
+        : (part === null || part === void 0 ? void 0 : part.reading) === 'truthiness' ? 'warning'
+            : undefined;
+};
+exports.conditionPartVerdict = conditionPartVerdict;
 /**
  * Whether an operation is offered where its result must be of `returnType`: a condition (`bool`) is
  * built from the operations whose result decides it, which is any result but text, a date or a time.