bruce-models 7.1.90 → 7.1.92

package/dist/bruce-models.umd.js

@@ -2905,9 +2905,22 @@
             EStatus["Denied"] = "Denied";
             EStatus["Cancelled"] = "Cancelled";
             EStatus["Sent"] = "Sent";
-            EStatus["NotSent"] = "NotSent";
+            EStatus["NotSent"] = "Not sent";
             EStatus["Accepted"] = "Accepted";
         })(EStatus = AccountInvite.EStatus || (AccountInvite.EStatus = {}));
+        /**
+         * Returns whether an invite is still awaiting a response from its recipient.
+         * Expiry is held as a timestamp rather than a status, so it is checked separately.
+         * @param invite
+         * @returns
+         */
+        function IsPending(invite) {
+            if (!invite || invite.IsExpired) {
+                return false;
+            }
+            return invite.Status === EStatus.Sent || invite.Status === EStatus.NotSent;
+        }
+        AccountInvite.IsPending = IsPending;
         /**
          * Possible invite methods.
          */
@@ -2952,22 +2965,61 @@
          */
         function GetList(params) {
             return __awaiter(this, void 0, void 0, function* () {
-                let { api, accountId, userId, req } = params;
+                let { api, accountId, userId, status, expired, expandUsers, expandGroups, pageSize, pageIndex, req } = params;
                 if (!api) {
                     api = exports.ENVIRONMENT.Api().GetGuardianApi();
                 }
                 const urlParams = new URLSearchParams();
                 if (accountId) {
-                    urlParams.append("accountId", accountId);
+                    urlParams.append("Account", accountId);
                 }
                 if (userId) {
-                    urlParams.append("userId", userId);
+                    urlParams.append("User", userId);
                 }
-                const res = yield api.GET("invites?" + urlParams.toString(), exports.Api.PrepReqParams(req));
-                return res;
+                if (status === null || status === void 0 ? void 0 : status.length) {
+                    urlParams.append("Status", status.join(","));
+                }
+                if (expired !== undefined && expired !== null) {
+                    urlParams.append("Expired", expired ? "true" : "false");
+                }
+                const expand = [];
+                if (expandUsers) {
+                    expand.push("user");
+                }
+                if (expandGroups) {
+                    expand.push("group");
+                }
+                if (expand.length) {
+                    urlParams.append("Expand", expand.join(","));
+                }
+                if (pageSize !== undefined && pageSize !== null) {
+                    urlParams.append("PageSize", String(pageSize));
+                }
+                if (pageIndex !== undefined && pageIndex !== null) {
+                    urlParams.append("PageIndex", String(pageIndex));
+                }
+                const res = yield api.GET("v3/accountInvites?" + urlParams.toString(), exports.Api.PrepReqParams(req));
+                return {
+                    invites: res.Items || [],
+                    totalCount: res.TotalCount,
+                    hasNextPage: res.HasNextPage,
+                    userGroups: res.UserGroup
+                };
             });
         }
         AccountInvite.GetList = GetList;
+        /**
+         * Returns the number of invites matching the criteria, without fetching any.
+         * @param params
+         * @returns
+         */
+        function GetCount(params) {
+            return __awaiter(this, void 0, void 0, function* () {
+                const res = yield GetList(Object.assign(Object.assign({}, params), { pageSize: -1, pageIndex: -1 }));
+                return res.totalCount || 0;
+            });
+        }
+        AccountInvite.GetCount = GetCount;
         /**
          * Updates an invite's status.
          * Once an invite is accepted or denied it cannot be changed.
@@ -2976,19 +3028,37 @@
          */
         function Update(params) {
             return __awaiter(this, void 0, void 0, function* () {
-                let { api, code, status, user, req } = params;
+                let { api, code, id, status, groupIds, user, req } = params;
                 if (!api) {
                     api = exports.ENVIRONMENT.Api().GetGuardianApi();
                 }
-                const res = yield api.POST("invite/update", {
+                if (!code && !id) {
+                    throw new Error("Either an invite ID or InviteCode must be provided.");
+                }
+                const invite = yield api.POST("v3/accountInvite", {
+                    ID: id,
                     InviteCode: code,
                     Status: status,
+                    "UserGroup.ID": groupIds,
                     User: user
                 }, exports.Api.PrepReqParams(req));
-                return res;
+                return {
+                    invite: invite
+                };
             });
         }
         AccountInvite.Update = Update;
+        /**
+         * Cancels a pending invite. Requires the session to be an account owner or admin.
+         * @param params
+         * @returns
+         */
+        function Cancel(params) {
+            return __awaiter(this, void 0, void 0, function* () {
+                return Update(Object.assign(Object.assign({}, params), { status: EStatus.Cancelled }));
+            });
+        }
+        AccountInvite.Cancel = Cancel;
         /**
          * Creates a new invite.
          * Please validate the response invitation records to ensure the desired contact method was used and worked.
@@ -2998,13 +3068,31 @@
          */
         function Create(params) {
             return __awaiter(this, void 0, void 0, function* () {
-                let { api, accountId, login, userId, email, mobile, emailTemplateKey, groupIds, req, inviteMethod } = params;
+                let { api, accountId, login, userId, email, mobile, emailTemplateKey, groupIds, req, inviteMethod, pending } = params;
                 if (!api) {
                     api = exports.ENVIRONMENT.Api().GetGuardianApi();
                 }
                 if (!(groupIds === null || groupIds === void 0 ? void 0 : groupIds.length)) {
                     throw new Error("At least one User Group ID must be provided.");
                 }
+                if (pending) {
+                    const res = yield api.POST("v3/createAccountInvite", {
+                        Account: accountId,
+                        Username: login,
+                        Email: email,
+                        Mobile: mobile,
+                        "User.ID": userId,
+                        "UserGroup.ID": groupIds,
+                        "Email.Template": emailTemplateKey,
+                        Method: inviteMethod
+                    }, exports.Api.PrepReqParams(req));
+                    return {
+                        warnings: res.Warning,
+                        user: res["Invited.User"],
+                        invite: res,
+                        manualInviteCode: res.InviteCode
+                    };
+                }
                 const res = yield api.POST("invite/new", {
                     accountId,
                     login,
@@ -17442,6 +17530,96 @@
         ImportLcc.ImportEntities = ImportEntities;
     })(exports.ImportLcc || (exports.ImportLcc = {}));
 
+    (function (ImportTif) {
+        /**
+         * A few vertical CRSs a user is likely to be choosing between. Any EPSG vertical code is
+         * accepted, so this is a convenience rather than the permitted set.
+         */
+        let EVerticalDatum;
+        (function (EVerticalDatum) {
+            // Heights are already on the ellipsoid, or the source is not elevation.
+            EVerticalDatum[EVerticalDatum["None"] = 0] = "None";
+            EVerticalDatum[EVerticalDatum["NAVD88"] = 5703] = "NAVD88";
+            EVerticalDatum[EVerticalDatum["EGM96"] = 5773] = "EGM96";
+            EVerticalDatum[EVerticalDatum["EGM2008"] = 3855] = "EGM2008";
+            EVerticalDatum[EVerticalDatum["NZVD2016"] = 7839] = "NZVD2016";
+        })(EVerticalDatum = ImportTif.EVerticalDatum || (ImportTif.EVerticalDatum = {}));
+        /**
+         * Reads an analysis out of a completed Pending Action.
+         * @param action the completed analyze action
+         * @returns the result, or null when the action carries none
+         */
+        function ReadAnalysis(action) {
+            if (!(action === null || action === void 0 ? void 0 : action.Result)) {
+                return null;
+            }
+            try {
+                const parsed = typeof action.Result === "string" ? JSON.parse(action.Result) : action.Result;
+                // A successful action wraps its answer; older ones returned it bare.
+                const result = (parsed === null || parsed === void 0 ? void 0 : parsed.success) && (parsed === null || parsed === void 0 ? void 0 : parsed.result) ? parsed.result : parsed;
+                return result && typeof result === "object" ? result : null;
+            }
+            catch (_a) {
+                return null;
+            }
+        }
+        ImportTif.ReadAnalysis = ReadAnalysis;
+        /**
+         * Whether the user has to be asked what the heights are referenced to.
+         * @param analysis the analysis result
+         * @returns true for elevation that declares no vertical CRS
+         */
+        function NeedsVerticalDatum(analysis) {
+            if (!analysis) {
+                return false;
+            }
+            return (analysis.type === exports.Tileset.EType.Terrain) && (analysis.verticalDeclared !== true);
+        }
+        ImportTif.NeedsVerticalDatum = NeedsVerticalDatum;
+        /**
+         * Whether the user has to be asked which CRS the source is in.
+         * @param analysis the analysis result
+         * @returns true when no horizontal CRS could be resolved at all
+         */
+        function NeedsHorizontalCrs(analysis) {
+            if (!analysis) {
+                return false;
+            }
+            return !(analysis.epsg && analysis.epsg > 0);
+        }
+        ImportTif.NeedsHorizontalCrs = NeedsHorizontalCrs;
+        /**
+         * Starts an analysis of an uploaded raster.
+         * @param params
+         * @returns the Pending Action to poll
+         */
+        function Analyze(params) {
+            return __awaiter(this, void 0, void 0, function* () {
+                let { api, analyze, req: reqParams } = params;
+                if (!api) {
+                    api = exports.ENVIRONMENT.Api().GetBruceApi();
+                }
+                return api.POST("import/analyze/tif", analyze, exports.Api.PrepReqParams(reqParams));
+            });
+        }
+        ImportTif.Analyze = Analyze;
+        /**
+         * Imports an analysed raster: the API creates the tileset and starts generating it.
+         * @param params
+         * @returns the created tileset and the Pending Action to poll
+         */
+        function Import(params) {
+            return __awaiter(this, void 0, void 0, function* () {
+                let { api, fileImport, req: reqParams } = params;
+                if (!api) {
+                    api = exports.ENVIRONMENT.Api().GetBruceApi();
+                }
+                return api.POST("import/tif", fileImport, exports.Api.PrepReqParams(reqParams));
+            });
+        }
+        ImportTif.Import = Import;
+    })(exports.ImportTif || (exports.ImportTif = {}));
+
     (function (ImportedFile) {
         /**
          * Returns cache identifier for a imported file record.
@@ -18713,7 +18891,13 @@
 
                         window["${resultId}"] = Invoke(window["${argsId}"], window["${contextId}"]);
                     }
-                    invoke();
+                    // Called with a receiver, not bare. The API builds index.jsc by
+                    // wrapping the plugin's index.js in a controller shell that
+                    // assigns 'this.Init = ...', and under "use strict" a bare call
+                    // leaves 'this' undefined, so every plugin would die on that
+                    // line before its own code ran. A throwaway object satisfies
+                    // the shell without giving the plugin the global scope back.
+                    invoke.call({});
                 `;
                         try {
                             // 'eval2 = eval' stops the linter from complaining about using eval.
@@ -18792,6 +18976,24 @@
          * and nothing downstream reports that it happened.
          */
         const STRICT_INCOMPATIBLE_KEYWORDS = ["$ref", "$defs", "allOf", "not"];
+        /** Depth beyond which a schema is refused as unverifiable rather than assumed clean. */
+        const MAX_SCHEMA_DEPTH = 32;
+        /**
+         * Keys whose values are author-named property maps rather than schemas.
+         *
+         * Everything under them is a name the author chose, so a property legitimately
+         * called "not" or "allOf" is not a keyword and must not be matched as one.
+         */
+        const PROPERTY_NAME_HOLDERS = ["properties", "patternProperties", "definitions", "dependentSchemas"];
+        /**
+         * Shortest timeout the host can actually apply.
+         *
+         * It converts the declared value to seconds by integer division, so anything
+         * below this truncates to zero.
+         */
+        const MIN_TIMEOUT_MS = 1000;
+        /** Longest timeout an account may declare. */
+        const MAX_TIMEOUT_MS = 120000;
         /**
          * Side effects an AI Tool may declare.
          *
@@ -18807,9 +19009,14 @@
          * @returns the offending keyword, or null
          */
         function findStrictModeViolation(node, depth = 0) {
-            if (!node || typeof node !== "object" || depth > 32) {
+            if (!node || typeof node !== "object") {
                 return null;
             }
+            if (depth > MAX_SCHEMA_DEPTH) {
+                // Returning "clean" here would let a $ref nested past the cap through
+                // as verified, which is the exact thing this walk exists to catch.
+                return `a schema nested deeper than ${MAX_SCHEMA_DEPTH} levels, which cannot be checked`;
+            }
             if (Array.isArray(node)) {
                 for (const child of node) {
                     const nested = findStrictModeViolation(child, depth + 1);
@@ -18819,11 +19026,28 @@
                 }
                 return null;
             }
+            // A keyword only counts at a schema position. Under "properties" and
+            // friends the field names are chosen by the author, so a property
+            // legitimately called "not" or "allOf" is a name, not a keyword.
             for (const key of Object.keys(node)) {
                 if (STRICT_INCOMPATIBLE_KEYWORDS.includes(key)) {
                     return key;
                 }
-                const nested = findStrictModeViolation(node[key], depth + 1);
+            }
+            for (const key of Object.keys(node)) {
+                const child = node[key];
+                if (PROPERTY_NAME_HOLDERS.includes(key)) {
+                    if (child && typeof child === "object" && !Array.isArray(child)) {
+                        for (const name of Object.keys(child)) {
+                            const nested = findStrictModeViolation(child[name], depth + 2);
+                            if (nested) {
+                                return nested;
+                            }
+                        }
+                    }
+                    continue;
+                }
+                const nested = findStrictModeViolation(child, depth + 1);
                 if (nested) {
                     return nested;
                 }
@@ -18863,9 +19087,14 @@
             // tool does. The description is the only thing the agent can select on:
             // without one it is registered but never chosen, and nothing reports that.
             const description = typeof tool.description === "string" ? tool.description.trim() : "";
-            if (!description && !((_c = plugin.Name) !== null && _c !== void 0 ? _c : "").trim()) {
-                return "An AI Tool needs a description. Set Settings.tool.description, or fill in the plugin's "
-                    + "Name and Description — the agent has nothing else to choose the tool on.";
+            // The fallback is "Name: Description", so a plugin with only a Name yields
+            // a description of a few words. That satisfied the old check while leaving
+            // the agent almost nothing to select on -- and since Save is disabled while
+            // Name is empty, the old check could never fire at all.
+            if (!description && !((_c = plugin.Description) !== null && _c !== void 0 ? _c : "").trim()) {
+                return "An AI Tool needs a description saying what it does and when to use it. Set "
+                    + "Settings.tool.description, or fill in the plugin's Description — the tool name is "
+                    + "an opaque ID, so this is the only thing the agent can choose it on.";
             }
             if (!isPlainObject(tool.inputSchema)) {
                 return "Settings.tool.inputSchema is missing or is not an object.";
@@ -18890,6 +19119,21 @@
                 }
             }
             if (annotations.timeoutMs !== undefined) {
+                if (typeof annotations.timeoutMs === "number"
+                    && isFinite(annotations.timeoutMs)
+                    && annotations.timeoutMs > 0
+                    && annotations.timeoutMs < MIN_TIMEOUT_MS) {
+                    // The host converts this to seconds by integer division, so
+                    // anything under a second becomes no wait at all -- the opposite
+                    // of a short timeout, and the tool then fails on every call.
+                    return `timeoutMs is ${annotations.timeoutMs}ms, but the shortest timeout the host can `
+                        + `apply is ${MIN_TIMEOUT_MS}ms. A smaller value would be rounded down to no wait at all.`;
+                }
+                if (typeof annotations.timeoutMs === "number"
+                    && isFinite(annotations.timeoutMs)
+                    && annotations.timeoutMs > MAX_TIMEOUT_MS) {
+                    return `timeoutMs is ${annotations.timeoutMs}ms, above the maximum of ${MAX_TIMEOUT_MS}ms.`;
+                }
                 if (typeof annotations.timeoutMs !== "number"
                     || !isFinite(annotations.timeoutMs)
                     || annotations.timeoutMs <= 0) {
@@ -22893,7 +23137,7 @@
     })(exports.UrlUtils || (exports.UrlUtils = {}));
 
     // This is updated with the package.json version on build.
-    const VERSION = "7.1.90";
+    const VERSION = "7.1.92";
 
     exports.VERSION = VERSION;
     exports.AbstractApi = AbstractApi;