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

package/dist/helpers/templateTree.js

@@ -0,0 +1,892 @@
+"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 __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+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.withServerCompletions = exports.withTemplateContexts = exports.TEMPLATE_CONTEXTS_LABEL = exports.templateContextsOf = exports.wholeContextValue = exports.WHOLE_TEMPLATE_CONTEXTS = exports.templateContextOf = exports.referenceNamesNothingMessage = exports.referenceNamesNothing = exports.catalogueGroupFor = exports.templateNodeIntent = exports.templateRowIntent = exports.TEMPLATE_INTENT_MEANINGS = exports.catalogueRowTrail = exports.loadTemplateChildren = exports.referenceSteps = exports.chipPathLabel = exports.searchTemplateTree = exports.searchTemplateReferences = exports.templateNodeFor = exports.templateNodeById = exports.allTemplateNodes = exports.openLoneGroup = exports.templateTree = exports.fieldReference = exports.RECORD_FIELDS_LABEL = exports.templateNodeKindOf = exports.unbracedReference = exports.TEMPLATE_NODE_KIND_LABELS = void 0;
+var templateType_1 = require("./templateType");
+/** What a row says a node is, in words. A group says nothing: its members do. */
+exports.TEMPLATE_NODE_KIND_LABELS = {
+    group: undefined,
+    state: 'State data',
+    context: 'Context',
+    config: 'Config',
+    variable: 'Variable',
+    field: 'Field',
+    template: 'Template',
+    function: 'Function',
+    keyword: 'Keyword',
+};
+var text = function (value) {
+    return typeof value === 'string' && value.trim() ? value : undefined;
+};
+/** A reference as it reads without its braces: `$data:{a.b}` and `$data:a.b` are one reference. */
+var unbracedReference = function (reference) { return reference.replace(/[{}]/g, ''); };
+exports.unbracedReference = unbracedReference;
+var VARIABLE_CONTEXTS = new Set(['localvar', 'globalvar', 'autovar', 'var', 'transient']);
+var CONTEXT_CONTEXTS = new Set([
+    'local',
+    'timestamp',
+    'dynamic',
+    'static',
+    'temp',
+    'step',
+    'state',
+    'test',
+    'env',
+    'foreach',
+    'for',
+    'fsminput',
+]);
+/** What a reference is, by its context: `$data:` a Qog state's data, `$config:` a config item, `@` a field. */
+var templateNodeKindOf = function (reference) {
+    var _a;
+    if (!reference) {
+        return 'template';
+    }
+    if (reference.startsWith('@')) {
+        return 'field';
+    }
+    var context = (_a = /^\$([\w-]+):/.exec(reference)) === null || _a === void 0 ? void 0 : _a[1];
+    if (!context) {
+        return 'template';
+    }
+    if (context === 'data') {
+        return 'state';
+    }
+    if (context === 'config') {
+        return 'config';
+    }
+    if (context === 'record') {
+        return 'field';
+    }
+    if (VARIABLE_CONTEXTS.has(context)) {
+        return 'variable';
+    }
+    return CONTEXT_CONTEXTS.has(context) ? 'context' : 'template';
+};
+exports.templateNodeKindOf = templateNodeKindOf;
+/**
+ * The reference every one of `references` goes on from, ending before a `.` (`$data:a` for `$data:a.b` and
+ * `$data:a.c`); none where they share no such start (`$local:x` and `$timestamp:y`).
+ */
+var sharedReference = function (references) {
+    if (!references.length) {
+        return undefined;
+    }
+    var shared = references[0];
+    for (var _i = 0, _a = references.slice(1); _i < _a.length; _i++) {
+        var reference_1 = _a[_i];
+        var i = 0;
+        while (i < shared.length && i < reference_1.length && shared[i] === reference_1[i]) {
+            i++;
+        }
+        shared = shared.slice(0, i);
+    }
+    /* What all of them start with, cut back to a whole step: the members of `$data:a` all start `$data:a.`, and a
+       group whose members are one template stands for that template's parent. */
+    var dot = shared.lastIndexOf('.');
+    if (dot <= 0) {
+        return undefined;
+    }
+    var reference = shared.slice(0, dot);
+    return /^\$[\w-]+:./.test(reference) || /^@./.test(reference) ? reference : undefined;
+};
+var writesKey = function (value) { return !!value && /:\*$/.test(value); };
+/** A node and its members from a catalogue row. */
+var nodeOf = function (row, id, trail, trailIds, wholeRecords) {
+    var _a, _b, _c, _d;
+    var value = text(row.value);
+    var label = (_b = (_a = text(row.label)) !== null && _a !== void 0 ? _a : value) !== null && _b !== void 0 ? _b : '';
+    var childTrail = __spreadArray(__spreadArray([], trail, true), [label], false);
+    var childTrailIds = __spreadArray(__spreadArray([], trailIds, true), [id], false);
+    var children = Array.isArray(row.items) ?
+        row.items.map(function (child, index) {
+            return nodeOf(child, "".concat(id, ".").concat(index), childTrail, childTrailIds, wholeRecords);
+        })
+        : undefined;
+    var memberReferences = (children !== null && children !== void 0 ? children : [])
+        .map(function (child) { return child.reference; })
+        .filter(function (reference) { return !!reference; });
+    var reference = value ? (0, exports.unbracedReference)(value)
+        : (children === null || children === void 0 ? void 0 : children.length) ? sharedReference(memberReferences)
+            : undefined;
+    var isGroup = !!(children === null || children === void 0 ? void 0 : children.length) || !!row.loadItems;
+    var node = {
+        id: id,
+        label: label,
+        value: value,
+        reference: reference,
+        kind: value ? (0, exports.templateNodeKindOf)(value)
+            : isGroup ? 'group'
+                : (0, exports.templateNodeKindOf)(reference),
+        type: value ? (0, templateType_1.templateType)(row) : undefined,
+        baseType: value ? (0, templateType_1.templateBaseType)(row) : undefined,
+        description: (_d = text((_c = row.metadata) === null || _c === void 0 ? void 0 : _c.description)) !== null && _d !== void 0 ? _d : text(row.description),
+        source: text(row.source),
+        trail: trail,
+        trailIds: trailIds,
+        disabled: row.disabled,
+        writesKey: writesKey(value),
+        row: row,
+    };
+    if (children === null || children === void 0 ? void 0 : children.length) {
+        node.children = children;
+    }
+    if (row.loadItems) {
+        var load_1 = row.loadItems;
+        node.loadChildren = function () { return __awaiter(void 0, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, load_1()];
+                    case 1: return [2 /*return*/, (_a.sent()).map(function (child, index) {
+                            return nodeOf(child, "".concat(id, ".").concat(index), childTrail, childTrailIds, wholeRecords);
+                        })];
+                }
+            });
+        }); };
+    }
+    // a group of one context's data says it is that context's: a Qog state's members are its data
+    if (node.kind === 'group' && reference) {
+        var membersKind = (0, exports.templateNodeKindOf)(reference);
+        if (membersKind !== 'template') {
+            node.kind = membersKind;
+        }
+    }
+    /* Taken whole: a record that is a value of its own, where its catalogue keeps its "select whole" (a type filter
+       takes it away where the record's value does not fit the field) and the field takes records at all; a Qog
+       state's data, written `$data:{state}`, where the field takes records (`wholeRecords`). */
+    if (isGroup) {
+        var keepsWhole = !('leftAction' in row) || !!row.leftAction;
+        if (value) {
+            node.takesWhole = wholeRecords !== false && keepsWhole;
+        }
+        else if (wholeRecords && reference && /^\$data:[^.{}]+$/.test(reference)) {
+            node.value = "$data:{".concat(reference.slice('$data:'.length), "}");
+            node.type = 'hash';
+            node.takesWhole = true;
+        }
+    }
+    return node;
+};
+/** The name of the group a DPQL field's record fields are listed under. */
+exports.RECORD_FIELDS_LABEL = 'Record fields';
+/** The nodes of a record's fields, each a group of its own fields where it is a record (`@customer.name`). */
+var fieldNodes = function (fields, parentId, trail, prefix) {
+    return Object.keys(fields).map(function (name, index) {
+        var _a, _b;
+        var field = fields[name];
+        var value = prefix === '@' ? (0, exports.fieldReference)(name) : "".concat(prefix, ".").concat(name);
+        /* named by its key, as it is written (`@name`) and as its chip names it ("record: name"); its display name
+           and description say what it is */
+        var said = [
+            (field === null || field === void 0 ? void 0 : field.display_name) && field.display_name !== name ? field.display_name : undefined,
+            (_a = field === null || field === void 0 ? void 0 : field.short_desc) !== null && _a !== void 0 ? _a : field === null || field === void 0 ? void 0 : field.desc,
+        ].filter(Boolean);
+        var id = "".concat(parentId, ".").concat(index);
+        var members = (_b = field === null || field === void 0 ? void 0 : field.fields) !== null && _b !== void 0 ? _b : (typeof (field === null || field === void 0 ? void 0 : field.type) === 'object' && !Array.isArray(field.type) ?
+            field.type.fields
+            : undefined);
+        return __assign({ id: id, label: name, value: value, reference: value, kind: 'field', type: fieldTypeName(field === null || field === void 0 ? void 0 : field.type), description: said.length ? said.join(': ') : undefined, trail: trail, trailIds: __spreadArray([], trail.map(function (_, at) {
+                return parentId
+                    .split('.')
+                    .slice(0, at + 1)
+                    .join('.');
+            }), true) }, (members && Object.keys(members).length ?
+            { children: fieldNodes(members, id, __spreadArray(__spreadArray([], trail, true), [name], false), value), takesWhole: true }
+            : {}));
+    });
+};
+var fieldTypeName = function (type) {
+    return typeof type === 'string' ? type
+        : Array.isArray(type) ? type.join(' or ')
+            : type === null || type === void 0 ? void 0 : type.name;
+};
+/**
+ * A record field's key as DPQL writes it (`DpqlSerializer::fieldReferenceForKey`): bare where the tokenizer reads it
+ * bare and it has no dot (`@name`); else quoted, its dots escaped (`AbstractDataProvider::escapeFieldPathKey`), then
+ * its quotes and its backslashes but those before a dot (`DpqlSerializer::escapeFieldPath`): `@"order-id"`,
+ * `@"Unit\\.Price"`.
+ */
+var fieldReference = function (key) {
+    if (/^[\p{L}_][\p{L}\p{M}\p{N}_]*$/u.test(key)) {
+        return "@".concat(key);
+    }
+    var path = key.replace(/\\/g, '\\\\').replace(/\./g, '\\.');
+    var written = '';
+    for (var i = 0; i < path.length; i++) {
+        var char = path[i];
+        written +=
+            char === '"' ? '\\"'
+                : char === '\\' ?
+                    path[i + 1] === '.' ?
+                        '\\'
+                        : '\\\\'
+                    : char;
+    }
+    return "@\"".concat(written, "\"");
+};
+exports.fieldReference = fieldReference;
+/**
+ * The tree of what a field can refer to: its templates as their catalogue nests them, and the record's fields as
+ * a group of their own. A catalogue of one group is opened for the author: its members are the tree's top
+ * (`templateItemsToShow`).
+ */
+var templateTree = function (templates, _a) {
+    var _b;
+    var _c = _a === void 0 ? {} : _a, fields = _c.fields, wholeRecords = _c.wholeRecords, keepLoneGroup = _c.keepLoneGroup;
+    var rows = ((_b = templates === null || templates === void 0 ? void 0 : templates.items) !== null && _b !== void 0 ? _b : []);
+    var roots = rows
+        .filter(function (row) { return !row.divider; })
+        .map(function (row, index) { return nodeOf(row, String(index), [], [], wholeRecords); });
+    var fieldNames = Object.keys(fields !== null && fields !== void 0 ? fields : {});
+    if (fieldNames.length) {
+        var id = String(roots.length);
+        var trail = [exports.RECORD_FIELDS_LABEL];
+        roots.push({
+            id: id,
+            label: exports.RECORD_FIELDS_LABEL,
+            reference: undefined,
+            kind: 'field',
+            description: 'The fields of the record the expression is about',
+            trail: [],
+            trailIds: [],
+            children: fieldNodes(fields, id, trail, '@'),
+        });
+    }
+    return keepLoneGroup ? roots : (0, exports.openLoneGroup)(roots);
+};
+exports.templateTree = templateTree;
+/**
+ * A lone group opened: where it is the only one, its members are what there is to choose from. Where there are
+ * others - the record's fields, what the language server completes - it is kept whole, under its name (qorus#646,
+ * David's review: "Order data"'s templates stood loose beside Record fields), so a host that adds groups opens it
+ * only once they are added (`keepLoneGroup`).
+ */
+var openLoneGroup = function (roots) {
+    var _a;
+    return roots.length === 1 && ((_a = roots[0].children) === null || _a === void 0 ? void 0 : _a.length) && !roots[0].value ?
+        roots[0].children.map(function (child) { return lift(child, roots[0].id); })
+        : roots;
+};
+exports.openLoneGroup = openLoneGroup;
+/** A node with the group above it taken off its trail, as it is when that group is opened for the author. */
+var lift = function (node, liftedId) {
+    var at = node.trailIds.indexOf(liftedId);
+    var trail = at < 0 ? node.trail : node.trail.slice(at + 1);
+    var trailIds = at < 0 ? node.trailIds : node.trailIds.slice(at + 1);
+    return __assign(__assign(__assign({}, node), { trail: trail, trailIds: trailIds }), (node.children ? { children: node.children.map(function (child) { return lift(child, liftedId); }) } : {}));
+};
+/** Every node of the tree, depth first, as far as it is loaded. */
+var allTemplateNodes = function (roots) {
+    var out = [];
+    var walk = function (nodes) {
+        for (var _i = 0, _a = nodes !== null && nodes !== void 0 ? nodes : []; _i < _a.length; _i++) {
+            var node = _a[_i];
+            out.push(node);
+            walk(node.children);
+        }
+    };
+    walk(roots);
+    return out;
+};
+exports.allTemplateNodes = allTemplateNodes;
+/** The node with `id`, if the tree has it loaded. */
+var templateNodeById = function (roots, id) {
+    return id === undefined ? undefined : (0, exports.allTemplateNodes)(roots).find(function (node) { return node.id === id; });
+};
+exports.templateNodeById = templateNodeById;
+/**
+ * The node a written reference is: its value in either spelling (`$data:{a.b}`, `$data:a.b`), or one of the other
+ * spellings its catalogue row answers to (`metadata.aliasValues`).
+ */
+var templateNodeFor = function (roots, written) {
+    var reference = (0, exports.unbracedReference)(written);
+    return (0, exports.allTemplateNodes)(roots).find(function (node) {
+        var _a, _b;
+        return (!!node.value && (node.value === written || node.reference === reference)) ||
+            (Array.isArray((_b = (_a = node.row) === null || _a === void 0 ? void 0 : _a.metadata) === null || _b === void 0 ? void 0 : _b.aliasValues) &&
+                node.row.metadata.aliasValues.some(function (alias) {
+                    return typeof alias === 'string' &&
+                        (alias === written || (0, exports.unbracedReference)(alias) === reference);
+                }));
+    });
+};
+exports.templateNodeFor = templateNodeFor;
+/**
+ * The nodes a reference being typed reaches (`$`, `$d`, `$data:`, `$data:receive_order.`, `@na`), as typing
+ * narrows them: each node whose reference starts with what is typed, and not the members of one that does - the
+ * group is offered, and opened for its members. `$d` and `$data` offer the states; `$data:` offers them too;
+ * `$data:receive_order.` offers that state's data. Nothing that does not go on from what is typed is offered.
+ */
+var searchTemplateReferences = function (roots, typed) {
+    var written = (0, exports.unbracedReference)(typed).toLowerCase();
+    /* `@` names a field of the record, as `$record:` does: a field the catalogue lists as a template
+       (`$record:{pos}`) is reached by `@po` too. */
+    var wanted = written.startsWith('@') ? [written, "$record:".concat(written.slice(1))] : [written];
+    var out = [];
+    var walk = function (nodes) {
+        var _a, _b;
+        var _loop_1 = function (node) {
+            var reference = (_a = node.reference) === null || _a === void 0 ? void 0 : _a.toLowerCase();
+            /* a context written whole (`$local:`) is gone into: what is in it is offered, not the context again
+               (its catalogue's contexts are nodes of their own, `withTemplateCatalogue`) */
+            if (node.catalogue && reference && wanted.includes(reference)) {
+                walk(node.children);
+                return "continue";
+            }
+            if (reference &&
+                wanted.some(function (each) { return reference.startsWith(each); }) &&
+                (node.value || ((_b = node.children) === null || _b === void 0 ? void 0 : _b.length) || node.loadChildren)) {
+                out.push(node);
+                return "continue";
+            }
+            // into a group that what is typed may go on into: one of unrelated members, or one it is typed past
+            if (node.children && (!reference || wanted.some(function (each) { return each.startsWith(reference); }))) {
+                walk(node.children);
+            }
+        };
+        for (var _i = 0, _c = nodes !== null && nodes !== void 0 ? nodes : []; _i < _c.length; _i++) {
+            var node = _c[_i];
+            _loop_1(node);
+        }
+    };
+    walk(roots);
+    return out;
+};
+exports.searchTemplateReferences = searchTemplateReferences;
+/** Whether every word of `query` starts a word of `text`, or `text` holds it whole. */
+var matchesWords = function (text, query) {
+    var haystack = text.toLowerCase();
+    var words = haystack.split(/[^\p{L}\p{M}\p{N}]+/u).filter(Boolean);
+    return query
+        .toLowerCase()
+        .split(/\s+/)
+        .filter(Boolean)
+        .every(function (word) { return haystack.includes(word) || words.some(function (each) { return each.startsWith(word); }); });
+};
+/**
+ * The nodes a search box's words find, at any depth under `within` (the tree's top when not given): a reference
+ * (`$`, `@`) as typing finds it, anything else by the names of the node and the groups it is in, its value, its
+ * type and its description. Its members are not listed beside a group that is found: it is opened for them.
+ */
+var searchTemplateTree = function (roots, query, within) {
+    var _a;
+    var scope = (_a = within === null || within === void 0 ? void 0 : within.children) !== null && _a !== void 0 ? _a : roots;
+    var trimmed = query.trim();
+    if (!trimmed) {
+        return scope;
+    }
+    if (/^[$@]/.test(trimmed)) {
+        return (0, exports.searchTemplateReferences)(scope, trimmed);
+    }
+    var out = [];
+    var walk = function (nodes) {
+        var _a;
+        var _loop_2 = function (node) {
+            var searched = __spreadArray([
+                node.label,
+                node.value,
+                node.type,
+                node.description,
+                node.source
+            ], node.trail, true).filter(Boolean)
+                .join(' ');
+            /* Found by all of its words, and by its own name for at least one of them: a group's members all have the
+               group's name in their trail, and are found under it, not beside it. */
+            var ownName = "".concat(node.label, " ").concat(node.value ? ((_a = (0, exports.referenceSteps)(node.value).pop()) !== null && _a !== void 0 ? _a : '') : '');
+            if (matchesWords(searched, trimmed) &&
+                trimmed.split(/\s+/).some(function (word) { return matchesWords(ownName, word); })) {
+                out.push(node);
+                return "continue";
+            }
+            walk(node.children);
+        };
+        for (var _i = 0, _b = nodes !== null && nodes !== void 0 ? nodes : []; _i < _b.length; _i++) {
+            var node = _b[_i];
+            _loop_2(node);
+        }
+    };
+    walk(scope);
+    return out;
+};
+exports.searchTemplateTree = searchTemplateTree;
+/**
+ * A reference's name as a chip says it: the outermost group, the last two steps, and "…" for the steps between
+ * (`Receive order › … › address › city`); up to three steps are said whole. Its whole path is the chip's hover.
+ */
+var chipPathLabel = function (trail, label) {
+    var steps = __spreadArray(__spreadArray([], trail.filter(Boolean), true), [label], false);
+    return steps.length <= 3 ? steps.join(' › ') : __spreadArray([steps[0], '…'], steps.slice(-2), true).join(' › ');
+};
+exports.chipPathLabel = chipPathLabel;
+/** The steps a reference no catalogue lists is written in (`$data:{a.b.c}` → `a`, `b`, `c`), for its chip's name. */
+var referenceSteps = function (written) {
+    var reference = (0, exports.unbracedReference)(written);
+    var body = reference.replace(/^\$[\w-]+:/, '').replace(/^@/, '');
+    return body.split('.').filter(Boolean);
+};
+exports.referenceSteps = referenceSteps;
+/** The members of `node`, asking its host for them where they come only when asked; its members as loaded. */
+var loadTemplateChildren = function (node) { return __awaiter(void 0, void 0, void 0, function () {
+    var children;
+    return __generator(this, function (_a) {
+        switch (_a.label) {
+            case 0:
+                if (node.children) {
+                    return [2 /*return*/, node.children];
+                }
+                if (!node.loadChildren) {
+                    return [2 /*return*/, []];
+                }
+                return [4 /*yield*/, node.loadChildren()];
+            case 1:
+                children = _a.sent();
+                node.children = children;
+                return [2 /*return*/, children];
+        }
+    });
+}); };
+exports.loadTemplateChildren = loadTemplateChildren;
+/* A catalogue's tree, kept for as long as the catalogue: a form hands the same catalogue to every row it draws, and
+   each chip asks for its name on every render. */
+var CATALOGUE_INDEXES = new WeakMap();
+var catalogueIndex = function (templates) {
+    var index = CATALOGUE_INDEXES.get(templates);
+    if (!index) {
+        var roots = (0, exports.templateTree)(templates);
+        var nodes = (0, exports.allTemplateNodes)(roots);
+        index = {
+            roots: roots,
+            byRow: new Map(nodes.filter(function (node) { return node.row; }).map(function (node) { return [node.row, node]; })),
+            byId: new Map(nodes.map(function (node) { return [node.id, node]; })),
+        };
+        CATALOGUE_INDEXES.set(templates, index);
+    }
+    return index;
+};
+/**
+ * Where a catalogue row is, for its chip and its hover: the names of the groups it is in that are data it is part
+ * of (`data`: a Qog state, a record - what a chip says before its name), and of every group it is in (`all`: with
+ * the groups that only gather templates, such as Context Data - what its hover says).
+ */
+var catalogueRowTrail = function (templates, row) {
+    if (!templates || !row || typeof row !== 'object') {
+        return { data: [], all: [] };
+    }
+    var index = catalogueIndex(templates);
+    var node = index.byRow.get(row);
+    if (!node) {
+        return { data: [], all: [] };
+    }
+    var ancestors = node.trailIds.map(function (id) { return index.byId.get(id); }).filter(Boolean);
+    return {
+        data: ancestors.filter(function (ancestor) { return !!ancestor.reference; }).map(function (ancestor) { return ancestor.label; }),
+        all: node.trail,
+    };
+};
+exports.catalogueRowTrail = catalogueRowTrail;
+/**
+ * What each color a template is drawn in means, as its hover says it (qorus#646, David: "what is the significance
+ * of the colors?"): green is the data of the event that starts the Qog, purple a value Qorus gives, blue any other
+ * template (which its hover does not need to say).
+ */
+exports.TEMPLATE_INTENT_MEANINGS = {
+    success: 'From the event that starts the Qog.',
+    custom1: 'A value Qorus gives.',
+    info: 'Any other data this value can use.',
+};
+/** The color a catalogue row's template is drawn in: its own metadata's, else its first member's. */
+var templateRowIntent = function (metadata) {
+    return (metadata === null || metadata === void 0 ? void 0 : metadata.isEventTrigger) ? 'success'
+        : (metadata === null || metadata === void 0 ? void 0 : metadata.builtIn) ? 'custom1'
+            : 'info';
+};
+exports.templateRowIntent = templateRowIntent;
+/** The color a node is drawn in: its row's, or for a group, that of the first of its members that has one. */
+var templateNodeIntent = function (node) {
+    var _a, _b;
+    var metadata = (_a = node.row) === null || _a === void 0 ? void 0 : _a.metadata;
+    if (metadata && (metadata.isEventTrigger || metadata.builtIn || node.value)) {
+        return (0, exports.templateRowIntent)(metadata);
+    }
+    var member = (_b = node.children) === null || _b === void 0 ? void 0 : _b.find(function (child) { var _a; return (_a = child.row) === null || _a === void 0 ? void 0 : _a.metadata; });
+    return member ? (0, exports.templateNodeIntent)(member) : (0, exports.templateRowIntent)(metadata);
+};
+exports.templateNodeIntent = templateNodeIntent;
+/* A catalogue's tree with each Qog state's data a value of its own (`$data:{state}`), kept for as long as the
+   catalogue, for the name of a state taken whole. */
+var WHOLE_STATE_TREES = new WeakMap();
+/**
+ * The group a reference stands for whole, where no row of the catalogue is it: a Qog state's data taken whole
+ * (`$data:{receive_order}`) is named by its state ("Receive order"), its whole path its hover's.
+ */
+var catalogueGroupFor = function (templates, written) {
+    var _a;
+    if (!templates) {
+        return undefined;
+    }
+    var roots = WHOLE_STATE_TREES.get(templates);
+    if (!roots) {
+        roots = (0, exports.templateTree)(templates, { wholeRecords: true });
+        WHOLE_STATE_TREES.set(templates, roots);
+    }
+    var node = (0, exports.templateNodeFor)(roots, written);
+    return node && (((_a = node.children) === null || _a === void 0 ? void 0 : _a.length) || node.loadChildren) ?
+        { label: node.label, path: __spreadArray(__spreadArray([], node.trail, true), [node.label], false).join(' › '), row: node.row }
+        : undefined;
+};
+exports.catalogueGroupFor = catalogueGroupFor;
+/**
+ * Whether a reference names nothing the field is given (qorus#646, David's review: a half-typed reference was left
+ * standing as if it were one): a reference into a context whose templates the catalogue lists, every one, which
+ * none of them is. A context the catalogue lists nothing of, or one whose keys are written freely (`$dynamic:*`),
+ * or a part of the catalogue not loaded yet, says nothing either way.
+ */
+var referenceNamesNothing = function (roots, written) {
+    var _a;
+    var reference = (0, exports.unbracedReference)(written);
+    var context = (_a = /^(\$[\w-]+:)./.exec(reference)) === null || _a === void 0 ? void 0 : _a[1];
+    if (!context || context === '$record:') {
+        return false;
+    }
+    var nodes = (0, exports.allTemplateNodes)(roots);
+    var inContext = nodes.filter(function (node) {
+        var _a;
+        return ((_a = node.reference) === null || _a === void 0 ? void 0 : _a.startsWith(context)) ||
+            (typeof node.value === 'string' && node.value.startsWith(context));
+    });
+    if (!inContext.length || inContext.some(function (node) { return node.writesKey; })) {
+        return false;
+    }
+    if ((0, exports.templateNodeFor)(roots, written)) {
+        return false;
+    }
+    // inside a group whose members are not loaded yet: not known to be nothing
+    return !inContext.some(function (node) {
+        var _a;
+        return !!node.loadChildren &&
+            !((_a = node.children) === null || _a === void 0 ? void 0 : _a.length) &&
+            !!node.reference &&
+            reference.startsWith("".concat((0, exports.unbracedReference)(node.reference), "."));
+    });
+};
+exports.referenceNamesNothing = referenceNamesNothing;
+/** What a diagnostic says of a reference that names nothing here. */
+var referenceNamesNothingMessage = function (written) {
+    return "No template here is called `".concat(written, "`: pick one from the list, or remove it.");
+};
+exports.referenceNamesNothingMessage = referenceNamesNothingMessage;
+/** The context a reference is in, with its `$` and `:` (`$data:` of `$data:receive_order.event_type`). */
+var templateContextOf = function (reference) { var _a; return reference ? (_a = /^(\$[\w-]+:)/.exec((0, exports.unbracedReference)(reference))) === null || _a === void 0 ? void 0 : _a[1] : undefined; };
+exports.templateContextOf = templateContextOf;
+/**
+ * The template contexts of the tree a `$` and what follows it start (qorus#646, David: "`$` → contexts"): each
+ * context its nodes are in (`$data:`, `$local:`, ...), as a node of its own whose members are its first nodes, in
+ * the order the tree lists them. Taking one writes it and goes on to what is in it.
+ */
+/**
+ * The template contexts Qorus reads as a hash, `*` the whole of it (UserApi `expandOneVariable()`: the contexts read
+ * with `getHashDotValue()`, which gives the whole hash for `*`, and those with a `"*"` case of their own; an argument
+ * `*` is read by `_priv_get_template_arg()`: `\*|\w+[\w.]*`). A context of these is a container: used whole as
+ * `$<context>:*` where the field takes a record (qorus#646, David's review).
+ */
+exports.WHOLE_TEMPLATE_CONTEXTS = new Set([
+    'autovar',
+    'config',
+    'data',
+    'dynamic',
+    'env',
+    'for',
+    'foreach',
+    'fsminput',
+    'globalvar',
+    'local',
+    'localvar',
+    'record',
+    'static',
+    'transient',
+    'var',
+    'xconfig',
+]);
+/** The whole of a context, as Qorus writes it: `$data:*`. */
+var wholeContextValue = function (context) { return "".concat(context, "*"); };
+exports.wholeContextValue = wholeContextValue;
+var templateContextsOf = function (roots, partial, wholeRecords) {
+    var _a, _b, _c;
+    if (partial === void 0) { partial = ''; }
+    var wanted = partial.toLowerCase();
+    /* the field's catalogue says which contexts it can use, and what each is (`withTemplateCatalogue`): those, as
+       it lists them - none guessed from the field's own templates */
+    var catalogued = (_b = (_a = roots
+        .find(function (node) { return node.id === 'contexts'; })) === null || _a === void 0 ? void 0 : _a.children) === null || _b === void 0 ? void 0 : _b.filter(function (node) { return node.catalogue; });
+    if (catalogued === null || catalogued === void 0 ? void 0 : catalogued.length) {
+        return catalogued.filter(function (node) { return node.catalogue.name.toLowerCase().startsWith(wanted); });
+    }
+    var contexts = new Map();
+    var nodes = (0, exports.allTemplateNodes)(roots);
+    var byId = new Map(nodes.map(function (node) { return [node.id, node]; }));
+    for (var _i = 0, nodes_1 = nodes; _i < nodes_1.length; _i++) {
+        var node = nodes_1[_i];
+        var context = (0, exports.templateContextOf)(node.reference);
+        if (!context || context === '$record:' || !context.slice(1).toLowerCase().startsWith(wanted))
+            continue;
+        var members = (_c = contexts.get(context)) !== null && _c !== void 0 ? _c : [];
+        // its first nodes: none whose group is in the same context already
+        var group = node.trailIds.length ? byId.get(node.trailIds[node.trailIds.length - 1]) : undefined;
+        if (!group || (0, exports.templateContextOf)(group.reference) !== context)
+            members.push(node);
+        contexts.set(context, members);
+    }
+    return Array.from(contexts.entries()).map(function (_a) {
+        var context = _a[0], members = _a[1];
+        var groups = Array.from(new Set(members.map(function (member) { var _a; return (_a = member.trail[0]) !== null && _a !== void 0 ? _a : member.label; })));
+        // used whole where the field takes a record and Qorus reads the context whole (`WHOLE_TEMPLATE_CONTEXTS`)
+        var whole = wholeRecords !== false && exports.WHOLE_TEMPLATE_CONTEXTS.has(context.slice(1, -1));
+        return __assign({ id: "context:".concat(context), label: context, reference: context, kind: 'context', description: groups.join(' · '), trail: [], trailIds: [], children: members }, (whole ? { value: (0, exports.wholeContextValue)(context), takesWhole: true } : {}));
+    });
+};
+exports.templateContextsOf = templateContextsOf;
+var SERVER_GROUPS = [
+    {
+        id: 'contexts',
+        label: 'Template contexts',
+        kind: 'context',
+        description: 'Write one and pick what is in it',
+    },
+    {
+        id: 'functions',
+        label: 'Functions',
+        kind: 'function',
+        description: 'What the expression can call',
+    },
+    {
+        id: 'keywords',
+        label: 'Values and keywords',
+        kind: 'keyword',
+        description: 'Literal values and operators',
+    },
+];
+/**
+ * The template picker's roots: the field's own (`templateTree`) and what the language server completes where a
+ * value can be written (qorus#646, David: "users should be supported with all available completions in the
+ * template picker" - the picker and typing offer the same set). The record's fields the server knows join the
+ * field's Record fields group (once each); the server's template contexts (each written and gone on from), its
+ * functions and its values and keywords are groups of their own.
+ */
+/** `node` and its members under another group: ids of their own (`prefix.`), its trail that group's. */
+var rehomed = function (node, prefix, trail, trailIds) { return (__assign(__assign(__assign({}, node), { id: "".concat(prefix, ".").concat(node.id), trail: trail, trailIds: trailIds }), (node.children ?
+    {
+        children: node.children.map(function (child) {
+            return rehomed(child, prefix, __spreadArray(__spreadArray([], trail, true), [node.label], false), __spreadArray(__spreadArray([], trailIds, true), ["".concat(prefix, ".").concat(node.id)], false));
+        }),
+    }
+    : {}))); };
+/** The name of the picker's group of template contexts. */
+exports.TEMPLATE_CONTEXTS_LABEL = 'Template contexts';
+/**
+ * The picker's roots with the template contexts of the field's own templates as a group of their own (qorus#646,
+ * David's review: every container that can be used has Use, and the picker offers what typing offers): each
+ * context - `$local:`, `$data:`, `$dynamic:` - a container of what is in it, used whole as `$<context>:*` where the
+ * value takes a record. Where there is more than one context; one alone is the field's group already.
+ */
+var withTemplateContexts = function (roots, wholeRecords) {
+    var contexts = (0, exports.templateContextsOf)(roots, '', wholeRecords);
+    /* only where it adds something: a context to take whole (the value takes a record) - for a value that takes no
+       record, the same templates again, regrouped */
+    if (contexts.length < 2 ||
+        !contexts.some(function (context) { return context.takesWhole; }) ||
+        roots.some(function (node) { return node.id === 'contexts'; })) {
+        return roots;
+    }
+    var id = 'contexts';
+    return __spreadArray(__spreadArray([], roots, true), [
+        {
+            id: id,
+            label: exports.TEMPLATE_CONTEXTS_LABEL,
+            kind: 'context',
+            description: 'Each context, to pick what is in it or to take it whole',
+            trail: [],
+            trailIds: [],
+            children: contexts.map(function (context) {
+                var _a;
+                return (__assign(__assign({}, context), { id: "".concat(id, ".").concat(context.id), trail: [exports.TEMPLATE_CONTEXTS_LABEL], trailIds: [id], children: ((_a = context.children) !== null && _a !== void 0 ? _a : []).map(function (member) {
+                        return rehomed(member, "".concat(id, ".").concat(context.id), [exports.TEMPLATE_CONTEXTS_LABEL, context.label], [id, "".concat(id, ".").concat(context.id)]);
+                    }) }));
+            }),
+        },
+    ], false);
+};
+exports.withTemplateContexts = withTemplateContexts;
+var withServerCompletions = function (roots, items, wholeRecords) {
+    var _a, _b;
+    if (!(items === null || items === void 0 ? void 0 : items.length))
+        return (0, exports.withTemplateContexts)(roots, wholeRecords);
+    var written = function (item) { var _a, _b, _c; return (_c = (_b = (_a = item.textEdit) === null || _a === void 0 ? void 0 : _a.newText) !== null && _b !== void 0 ? _b : item.insertText) !== null && _c !== void 0 ? _c : item.label; };
+    var describe = function (item) {
+        var _a, _b;
+        return typeof item.documentation === 'string' ?
+            item.documentation
+            : ((_b = (_a = item.documentation) === null || _a === void 0 ? void 0 : _a.value) !== null && _b !== void 0 ? _b : item.detail);
+    };
+    var known = new Set((0, exports.allTemplateNodes)(roots).flatMap(function (node) { return [node.value, node.reference].filter(Boolean); }));
+    var fields = items.filter(function (item) { return item.kind === 5 && /^@/.test(written(item)) && !known.has(written(item)); });
+    var contexts = items.filter(function (item) { return /^\$[\w-]+:$/.test(written(item)); });
+    var functions = items.filter(function (item) { return item.kind === 3 || item.kind === 2; });
+    var keywords = items.filter(function (item) {
+        return (item.kind === 14 || item.kind === 12 || item.kind === 24) && !/^[$@]/.test(written(item));
+    });
+    var out = roots;
+    if (fields.length) {
+        var fieldGroup_1 = roots.find(function (node) { return node.label === exports.RECORD_FIELDS_LABEL && node.kind === 'field'; });
+        var id_1 = (_a = fieldGroup_1 === null || fieldGroup_1 === void 0 ? void 0 : fieldGroup_1.id) !== null && _a !== void 0 ? _a : 'server.fields';
+        var trail_1 = [exports.RECORD_FIELDS_LABEL];
+        var extra_1 = fields.map(function (item, index) { return ({
+            id: "".concat(id_1, ".server.").concat(index),
+            label: item.label.replace(/^@/, ''),
+            value: written(item),
+            reference: written(item),
+            kind: 'field',
+            type: item.detail,
+            description: describe(item),
+            trail: trail_1,
+            trailIds: [id_1],
+        }); });
+        out =
+            fieldGroup_1 ?
+                out.map(function (node) { var _a; return node === fieldGroup_1 ? __assign(__assign({}, node), { children: __spreadArray(__spreadArray([], ((_a = node.children) !== null && _a !== void 0 ? _a : []), true), extra_1, true) }) : node; })
+                : __spreadArray(__spreadArray([], out, true), [
+                    {
+                        id: id_1,
+                        label: exports.RECORD_FIELDS_LABEL,
+                        kind: 'field',
+                        description: 'The fields of the record the expression is about',
+                        trail: [],
+                        trailIds: [],
+                        children: extra_1,
+                    },
+                ], false);
+    }
+    /* The template contexts, one group: the field's own (with what is in them) and those only the server offers -
+       each a container, gone on into, used whole as the server says (`data`: the contract a Qorus agent is
+       building) or as Qorus reads it (`WHOLE_TEMPLATE_CONTEXTS`). */
+    out = (0, exports.withTemplateContexts)(out, wholeRecords);
+    var ownContexts = new Set((0, exports.templateContextsOf)(roots).map(function (node) { return node.reference; }));
+    var serverOnly = contexts.filter(function (item) { return !ownContexts.has(written(item)); });
+    if (serverOnly.length || ownContexts.size === 1) {
+        var id_2 = 'contexts';
+        var group_1 = out.find(function (node) { return node.id === id_2; });
+        var fromServer = serverOnly.map(function (item, index) {
+            var _a, _b;
+            var context = written(item);
+            var said = ((_a = item.data) !== null && _a !== void 0 ? _a : {});
+            var whole = wholeRecords !== false &&
+                ((_b = said.use_whole) !== null && _b !== void 0 ? _b : exports.WHOLE_TEMPLATE_CONTEXTS.has(context.slice(1, -1)));
+            return __assign({ id: "".concat(id_2, ".server.").concat(index), label: context, reference: context, kind: 'context', description: describe(item), trail: [exports.TEMPLATE_CONTEXTS_LABEL], trailIds: [id_2], continues: true }, (whole ? { value: (0, exports.wholeContextValue)(context), takesWhole: true } : {}));
+        });
+        // a lone context of the field's own joins the group, with what is in it
+        var lone = !group_1 && ownContexts.size === 1 ?
+            (0, exports.templateContextsOf)(roots, '', wholeRecords).map(function (context) {
+                var _a;
+                return (__assign(__assign({}, context), { id: "".concat(id_2, ".").concat(context.id), trail: [exports.TEMPLATE_CONTEXTS_LABEL], trailIds: [id_2], children: ((_a = context.children) !== null && _a !== void 0 ? _a : []).map(function (member) {
+                        return rehomed(member, "".concat(id_2, ".").concat(context.id), [exports.TEMPLATE_CONTEXTS_LABEL, context.label], [id_2, "".concat(id_2, ".").concat(context.id)]);
+                    }) }));
+            })
+            : [];
+        var members_1 = __spreadArray(__spreadArray(__spreadArray([], ((_b = group_1 === null || group_1 === void 0 ? void 0 : group_1.children) !== null && _b !== void 0 ? _b : []), true), lone, true), fromServer, true).sort(function (a, b) {
+            return a.label.localeCompare(b.label);
+        });
+        out =
+            group_1 ?
+                out.map(function (node) { return (node === group_1 ? __assign(__assign({}, node), { children: members_1 }) : node); })
+                : __spreadArray(__spreadArray([], out, true), [
+                    {
+                        id: id_2,
+                        label: exports.TEMPLATE_CONTEXTS_LABEL,
+                        kind: 'context',
+                        description: 'Each context, to pick what is in it or to take it whole',
+                        trail: [],
+                        trailIds: [],
+                        children: members_1,
+                    },
+                ], false);
+    }
+    var byGroup = { contexts: [], functions: functions, keywords: keywords };
+    var _loop_3 = function (group) {
+        var members = byGroup[group.id];
+        if (!members.length)
+            return "continue";
+        var id = "server.".concat(group.id);
+        out = __spreadArray(__spreadArray([], out, true), [
+            {
+                id: id,
+                label: group.label,
+                kind: group.kind,
+                description: group.description,
+                trail: [],
+                trailIds: [],
+                children: members.map(function (item, index) { return (__assign({ id: "".concat(id, ".").concat(index), label: item.label, value: written(item), kind: group.kind, description: describe(item), trail: [group.label], trailIds: [id] }, (group.id === 'contexts' ? { continues: true, reference: written(item) } : {}))); }),
+            },
+        ], false);
+    };
+    for (var _i = 0, SERVER_GROUPS_1 = SERVER_GROUPS; _i < SERVER_GROUPS_1.length; _i++) {
+        var group = SERVER_GROUPS_1[_i];
+        _loop_3(group);
+    }
+    return out;
+};
+exports.withServerCompletions = withServerCompletions;
+//# sourceMappingURL=templateTree.js.map