@computec/uibase 1.0.8 → 1.0.10

package/dist-amd/communication/SignalRHubClient.js

@@ -0,0 +1,135 @@
+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 __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+define(["require", "exports", "../helpers/ErrorHelper"], function (require, exports, ErrorHelper_1) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    ErrorHelper_1 = __importDefault(ErrorHelper_1);
+    class SignalRHubClient {
+        get promise() {
+            return this.initialized;
+        }
+        get autoConnectPromise() {
+            return this.initialized;
+        }
+        get connection() {
+            return this._connection;
+        }
+        constructor(options) {
+            this.off = (methodName) => this._connection.off(methodName);
+            options = Object.assign({ useSharedConnection: false, rootPath: `${window.location.origin}/tnc`, autoConnect: true }, options);
+            this._globalConnections = [];
+            this.options = options;
+            this._connection = this._getConnection(this.options);
+            if (this.options.autoConnect) {
+                this.initialized = this.connect();
+            }
+            return this;
+        }
+        connect() {
+            return __awaiter(this, void 0, void 0, function* () {
+                return yield this.connection.start();
+            });
+        }
+        disconnect() {
+            this.connection.stop();
+            return;
+        }
+        subscribe(options) {
+            return this._subscribe(options);
+        }
+        on(methodName, callback) {
+            this.connection.on(methodName, callback);
+        }
+        _subscribe(options) {
+            return __awaiter(this, void 0, void 0, function* () {
+                try {
+                    yield this.initialized;
+                    const args = options.getAttributes();
+                    yield this.connection.invoke(options.Name, ...args);
+                }
+                catch (error) {
+                    const err = ErrorHelper_1.default.getError(error);
+                    console.error(`${err.name}:${err.message}`);
+                    console.error(err.stack);
+                    throw new Error(`Error while subscribing to function: ${err.name} ${err.message}`);
+                }
+            });
+        }
+        _addQueries(options) {
+            const queries = [];
+            if (options.companyId)
+                queries.push(`CompanyId=${options.companyId}`);
+            if (options.companyApiKey) {
+                queries.push(`ApiKey=${options.companyApiKey}`);
+            }
+            if (queries.length == 0)
+                return "";
+            return "?" + queries.join("&");
+        }
+        _initNewConnection(options) {
+            var _a;
+            let connection;
+            let hubConnectionBuilder = new signalR.HubConnectionBuilder();
+            if (options.rootPath) {
+                const args = `${(_a = options.companyId) !== null && _a !== void 0 ? _a : ""} `;
+                hubConnectionBuilder = hubConnectionBuilder.withUrl(`${options.rootPath}${this._addQueries(options)}`);
+            }
+            hubConnectionBuilder = this._setAutoReconnect(hubConnectionBuilder, options);
+            if (options.keepAliveIntervalInMilliseconds && options.keepAliveIntervalInMilliseconds > 0) {
+                hubConnectionBuilder = hubConnectionBuilder.withKeepAliveInterval(options.keepAliveIntervalInMilliseconds);
+            }
+            if (options.serverTimeoutInMilliseconds && options.serverTimeoutInMilliseconds > 0) {
+                hubConnectionBuilder = hubConnectionBuilder.withServerTimeout(options.serverTimeoutInMilliseconds);
+            }
+            connection = hubConnectionBuilder.build();
+            return connection;
+        }
+        _setAutoReconnect(hubConnectionBuilder, options) {
+            if (!options.autoReconnect) {
+                return hubConnectionBuilder;
+            }
+            if (options.autoReconnectPolicy) {
+                return hubConnectionBuilder.withAutomaticReconnect(options.autoReconnectPolicy);
+            }
+            if (typeof options.autoReconnectInterval === "number") {
+                return hubConnectionBuilder.withAutomaticReconnect([options.autoReconnectInterval]);
+            }
+            if (Array.isArray(options.autoReconnectInterval) && options.autoReconnectInterval.length > 0) {
+                return hubConnectionBuilder.withAutomaticReconnect(options.autoReconnectInterval);
+            }
+            return hubConnectionBuilder.withAutomaticReconnect();
+        }
+        _getSharedConnection(options) {
+            let existingConnectionInfo = this._globalConnections.find((ci) => ci.path === options.rootPath);
+            let connection;
+            if (!existingConnectionInfo) {
+                connection = this._initNewConnection(this.options);
+                existingConnectionInfo = {
+                    path: options.rootPath,
+                    connection: connection,
+                };
+                this._globalConnections.push(existingConnectionInfo);
+            }
+            return existingConnectionInfo === null || existingConnectionInfo === void 0 ? void 0 : existingConnectionInfo.connection;
+        }
+        _getConnection(options) {
+            if (this.options.useSharedConnection) {
+                return this._getSharedConnection(options);
+            }
+            else {
+                return this._initNewConnection(this.options);
+            }
+        }
+    }
+    exports.default = SignalRHubClient;
+});

package/dist-amd/communication/SignalRMessage.d.ts

@@ -0,0 +1,10 @@
+import BaseBusinessObject from "../models/BaseBusinessObject";
+import ISignalRMessage from "./ISignalRMessage";
+export default class SignalRMessage extends BaseBusinessObject implements ISignalRMessage {
+    CompanyId: string;
+    EventType: string;
+    FormType: string;
+    ObjectKey: string;
+    UserName: string;
+}
+//# sourceMappingURL=SignalRMessage.d.ts.map

package/dist-amd/communication/SignalRMessage.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"SignalRMessage.d.ts","sourceRoot":"","sources":["../../src/communication/SignalRMessage.ts"],"names":[],"mappings":"AAAA,OAAO,kBAAkB,MAAM,8BAA8B,CAAC;AAC9D,OAAO,eAAe,MAAM,mBAAmB,CAAC;AAEhD,MAAM,CAAC,OAAO,OAAO,cAAe,SAAQ,kBAAmB,YAAW,eAAe;IACxF,SAAS,EAAE,MAAM,CAAC;IAClB,SAAS,EAAE,MAAM,CAAC;IAClB,QAAQ,EAAE,MAAM,CAAC;IACjB,SAAS,EAAE,MAAM,CAAC;IAClB,QAAQ,EAAE,MAAM,CAAC;CACjB"}

package/dist-amd/communication/SignalRMessage.js

@@ -0,0 +1,11 @@
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+define(["require", "exports", "../models/BaseBusinessObject"], function (require, exports, BaseBusinessObject_1) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    BaseBusinessObject_1 = __importDefault(BaseBusinessObject_1);
+    class SignalRMessage extends BaseBusinessObject_1.default {
+    }
+    exports.default = SignalRMessage;
+});

package/dist-amd/communication/SubscribeProperties.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Represents properties used for subscribing to a SignalR hub or similar event source.
+ */
+export declare class SubscribeProperties {
+    Name: string;
+    /**
+     * Creates an instance of SubscribeProperties.
+     * @param {string} Name - The name of the subscription property.
+     */
+    constructor(Name: string);
+    /**
+     * Returns all attributes of the instance except the 'Name' property.
+     * @returns {any[]} An array of attribute values excluding 'Name'.
+     */
+    getAttributes(): any[];
+}
+//# sourceMappingURL=SubscribeProperties.d.ts.map

package/dist-amd/communication/SubscribeProperties.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"SubscribeProperties.d.ts","sourceRoot":"","sources":["../../src/communication/SubscribeProperties.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,qBAAa,mBAAmB;IAKZ,IAAI,EAAE,MAAM;IAJ/B;;;OAGG;gBACgB,IAAI,EAAE,MAAM;IAE/B;;;OAGG;IACH,aAAa;CAKb"}

package/dist-amd/communication/SubscribeProperties.js

@@ -0,0 +1,27 @@
+define(["require", "exports"], function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.SubscribeProperties = void 0;
+    /**
+     * Represents properties used for subscribing to a SignalR hub or similar event source.
+     */
+    class SubscribeProperties {
+        /**
+         * Creates an instance of SubscribeProperties.
+         * @param {string} Name - The name of the subscription property.
+         */
+        constructor(Name) {
+            this.Name = Name;
+        }
+        /**
+         * Returns all attributes of the instance except the 'Name' property.
+         * @returns {any[]} An array of attribute values excluding 'Name'.
+         */
+        getAttributes() {
+            const idx = Object.keys(this).indexOf("Name");
+            const args = [...Object.values(this).slice(0, idx), ...Object.values(this).slice(idx + 1)];
+            return args;
+        }
+    }
+    exports.SubscribeProperties = SubscribeProperties;
+});

package/dist-amd/helpers/ErrorHelper.d.ts

@@ -0,0 +1,15 @@
+export default class ErrorHelper {
+    /**
+     * @description Helper method that try to return Error type
+     * @returns
+     */
+    static getError(error: any): Error;
+    /**
+     * Check if the error is an AppEngineException
+     * @deprecated **Use AppEngineException.is instead**
+     * @param error any object
+     * @returns boolean
+     */
+    static isAppEngineException(error: any): error is import("../index").IAppEngineException;
+}
+//# sourceMappingURL=ErrorHelper.d.ts.map

package/dist-amd/helpers/ErrorHelper.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ErrorHelper.d.ts","sourceRoot":"","sources":["../../src/helpers/ErrorHelper.ts"],"names":[],"mappings":"AAMA,MAAM,CAAC,OAAO,OAAO,WAAW;IAC/B;;;OAGG;WACW,QAAQ,CAAC,KAAK,EAAE,GAAG,GAAG,KAAK;IAuBzC;;;;;OAKG;WACW,oBAAoB,CAAC,KAAK,EAAE,GAAG;CAG7C"}

package/dist-amd/helpers/ErrorHelper.js

@@ -0,0 +1,51 @@
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+define(["require", "exports", "../models/ValidationProblemDetails", "../models/AppEngineException", "../models/ProblemDetails", "../models/OdataError", "../models/DocumentedException"], function (require, exports, ValidationProblemDetails_1, AppEngineException_1, ProblemDetails_1, OdataError_1, DocumentedException_1) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    ValidationProblemDetails_1 = __importDefault(ValidationProblemDetails_1);
+    AppEngineException_1 = __importDefault(AppEngineException_1);
+    ProblemDetails_1 = __importDefault(ProblemDetails_1);
+    OdataError_1 = __importDefault(OdataError_1);
+    DocumentedException_1 = __importDefault(DocumentedException_1);
+    class ErrorHelper {
+        /**
+         * @description Helper method that try to return Error type
+         * @returns
+         */
+        static getError(error) {
+            var _a;
+            switch (true) {
+                case error instanceof Error:
+                    return error;
+                case typeof error === "string":
+                    return new Error(error);
+                case OdataError_1.default.is(error):
+                    return OdataError_1.default.create(error).error;
+                case ValidationProblemDetails_1.default.is(error):
+                    return ValidationProblemDetails_1.default.create(error).error;
+                case DocumentedException_1.default.is(error):
+                    return new DocumentedException_1.default(error).error;
+                case ProblemDetails_1.default.is(error):
+                    return ProblemDetails_1.default.create(error).error;
+                case AppEngineException_1.default.is(error):
+                    return new AppEngineException_1.default(error).error;
+                case (_a = error === null || error === void 0 ? void 0 : error.error) === null || _a === void 0 ? void 0 : _a.message:
+                    return new Error(error.error.message);
+                default:
+                    return error;
+            }
+        }
+        /**
+         * Check if the error is an AppEngineException
+         * @deprecated **Use AppEngineException.is instead**
+         * @param error any object
+         * @returns boolean
+         */
+        static isAppEngineException(error) {
+            return AppEngineException_1.default.is(error);
+        }
+    }
+    exports.default = ErrorHelper;
+});

package/dist-amd/helpers/HttpClientHelper.d.ts

@@ -0,0 +1,42 @@
+import { IBasicHttpRequest } from "../communication/IBaseHttpClientOptions";
+export default class HttpClientHelper {
+    static readonly FULL_URL_PATTERN: RegExp;
+    static readonly NOT_AUTHENTICATED_ERROR_NAME = "RESPONSE_NOT_AUTHENTICATED";
+    /**
+     * @throws Error if response is not ok with message based on status code or response
+     */
+    static validateResponse(response: Response, restOptions: IBasicHttpRequest): Promise<boolean>;
+    /**
+     * @description Check if headers is an array of [string, string]
+     */
+    static isHeadersArrayType(headers: HeadersInit): headers is [string, string][];
+    /**
+     * @description Fetch data based on response content type
+     * @param response from fetch
+     * @returns
+     */
+    static fetchData(response: Response): Promise<any>;
+    /**
+     * @description prepares Url for fetch. If full url is provided, it will return it as is, otherwise it will append it to the current origin
+     * @param url
+     * @returns
+     */
+    static getFullUrl(url?: string): string;
+    /**
+     * @description Check if error is not authenticated
+     * @param error
+     * @returns
+     */
+    static isNotAuthenticated: (error: Error) => boolean;
+    private static _validateResponseType;
+    private static _throwErrorBasedOnResponse;
+    private static _getAcceptedType;
+    private static _isJsonType;
+    private static _isFileType;
+    private static _isTextType;
+    private static _isNullType;
+    private static _fetchJsonData;
+    private static _fetchFileData;
+    private static _fetchTextData;
+}
+//# sourceMappingURL=HttpClientHelper.d.ts.map

package/dist-amd/helpers/HttpClientHelper.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"HttpClientHelper.d.ts","sourceRoot":"","sources":["../../src/helpers/HttpClientHelper.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,iBAAiB,EAAE,MAAM,yCAAyC,CAAC;AAI5E,MAAM,CAAC,OAAO,OAAO,gBAAgB;IACpC,MAAM,CAAC,QAAQ,CAAC,gBAAgB,SAAmB;IACnD,MAAM,CAAC,QAAQ,CAAC,4BAA4B,gCAAgC;IAC5E;;OAEG;WACiB,gBAAgB,CAAC,QAAQ,EAAE,QAAQ,EAAE,WAAW,EAAE,iBAAiB;IASvF;;OAEG;WACW,kBAAkB,CAAC,OAAO,EAAE,WAAW,GAAG,OAAO,IAAI,CAAC,MAAM,EAAE,MAAM,CAAC,EAAE;IAiBrF;;;;OAIG;WACW,SAAS,CAAC,QAAQ,EAAE,QAAQ;IAO1C;;;;OAIG;WACW,UAAU,CAAC,GAAG,CAAC,EAAE,MAAM;IAMrC;;;;OAIG;IACH,OAAc,kBAAkB,GAAI,OAAO,KAAK,aACc;IAG9D,OAAO,CAAC,MAAM,CAAC,qBAAqB;mBAqBf,0BAA0B;IAwB/C,OAAO,CAAC,MAAM,CAAC,gBAAgB;IAU/B,OAAO,CAAC,MAAM,CAAC,WAAW;IAI1B,OAAO,CAAC,MAAM,CAAC,WAAW;IAoB1B,OAAO,CAAC,MAAM,CAAC,WAAW;IAI1B,OAAO,CAAC,MAAM,CAAC,WAAW;mBAIL,cAAc;mBASd,cAAc;mBASd,cAAc;CASnC"}

package/dist-amd/helpers/HttpClientHelper.js

@@ -0,0 +1,188 @@
+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 __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+define(["require", "exports", "./ErrorHelper", "../models/enums/HeadersContentTypeEnum"], function (require, exports, ErrorHelper_1, HeadersContentTypeEnum_1) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    ErrorHelper_1 = __importDefault(ErrorHelper_1);
+    HeadersContentTypeEnum_1 = __importDefault(HeadersContentTypeEnum_1);
+    class HttpClientHelper {
+        /**
+         * @throws Error if response is not ok with message based on status code or response
+         */
+        static validateResponse(response, restOptions) {
+            return __awaiter(this, void 0, void 0, function* () {
+                if (!response.ok) {
+                    yield this._throwErrorBasedOnResponse(response, restOptions);
+                }
+                this._validateResponseType(response, restOptions);
+                return true;
+            });
+        }
+        /**
+         * @description Check if headers is an array of [string, string]
+         */
+        static isHeadersArrayType(headers) {
+            if (!Array.isArray(headers)) {
+                return false;
+            }
+            for (let i = 0; i < headers.length; i++) {
+                if (!Array.isArray(headers[i]) || headers[i].length !== 2) {
+                    return false;
+                }
+                if (typeof headers[i][0] !== "string" || typeof headers[i][1] !== "string") {
+                    return false;
+                }
+            }
+            return true;
+        }
+        /**
+         * @description Fetch data based on response content type
+         * @param response from fetch
+         * @returns
+         */
+        static fetchData(response) {
+            const type = response.headers.get("Content-Type");
+            if (this._isJsonType(type))
+                return this._fetchJsonData(response);
+            if (this._isFileType(type))
+                return this._fetchFileData(response);
+            return this._fetchTextData(response);
+        }
+        /**
+         * @description prepares Url for fetch. If full url is provided, it will return it as is, otherwise it will append it to the current origin
+         * @param url
+         * @returns
+         */
+        static getFullUrl(url) {
+            if (!url)
+                return "";
+            if (this.FULL_URL_PATTERN.test(url))
+                return url;
+            return `${window.location.origin}/${url}`;
+        }
+        //#region Private methods
+        static _validateResponseType(response, restOptions) {
+            const responseType = response.headers.get("Content-Type");
+            const acceptedType = this._getAcceptedType(restOptions.headers);
+            let valid = true;
+            if (acceptedType) {
+                const acceptedTypesArray = acceptedType.split(",");
+                valid = acceptedTypesArray.some((acceptedType) => (this._isJsonType(acceptedType) && this._isJsonType(responseType)) ||
+                    (this._isTextType(acceptedType) && this._isTextType(responseType)) ||
+                    (this._isFileType(acceptedType) && this._isFileType(responseType)) ||
+                    (this._isNullType(acceptedType) && this._isNullType(responseType)));
+            }
+            if (!valid)
+                throw new Error(`Wrong content type. Accepted type for request: ${acceptedType}, received type in response: ${responseType}.`);
+        }
+        static _throwErrorBasedOnResponse(response, restOptions) {
+            return __awaiter(this, void 0, void 0, function* () {
+                switch (response.status) {
+                    case 401:
+                        const error = new Error();
+                        error.name = HttpClientHelper.NOT_AUTHENTICATED_ERROR_NAME;
+                        error.message = response.statusText;
+                        throw error;
+                    case 0:
+                        throw new Error("Server is not responding");
+                    case 404:
+                        throw new Error(`Not found ${restOptions.url}`);
+                    case 405:
+                        throw new Error(`Method ${restOptions.method} not allowed for endpoint: ${restOptions.url}`);
+                }
+                const result = yield this.fetchData(response);
+                throw ErrorHelper_1.default.getError(result);
+            });
+        }
+        static _getAcceptedType(headers) {
+            if (!headers)
+                return null;
+            if (headers instanceof Headers)
+                return headers.get("Accepted");
+            if (this.isHeadersArrayType(headers)) {
+                const accepted = headers.find(([key]) => key === "Accepted");
+                if (accepted !== undefined)
+                    return accepted[1];
+            }
+            return headers["Accepted"];
+        }
+        static _isJsonType(type) {
+            return type === null || type === void 0 ? void 0 : type.includes(HeadersContentTypeEnum_1.default.Json);
+        }
+        static _isFileType(type) {
+            if (!type)
+                return false;
+            // Explicitly exclude JSON and text types
+            if (this._isJsonType(type) || this._isTextType(type))
+                return false;
+            return (type.includes(HeadersContentTypeEnum_1.default.OctetStream) ||
+                type.includes(HeadersContentTypeEnum_1.default.Pdf) ||
+                type.includes(HeadersContentTypeEnum_1.default.Csv) ||
+                type.includes(HeadersContentTypeEnum_1.default.Excel) ||
+                type.includes(HeadersContentTypeEnum_1.default.ExcelOpenXml) ||
+                type.includes(HeadersContentTypeEnum_1.default.Word) ||
+                type.includes(HeadersContentTypeEnum_1.default.Zip) ||
+                type.includes("image/") ||
+                type.includes("audio/") ||
+                type.includes("video/"));
+        }
+        static _isTextType(type) {
+            return type === null || type === void 0 ? void 0 : type.includes(HeadersContentTypeEnum_1.default.Text);
+        }
+        static _isNullType(type) {
+            return type === HeadersContentTypeEnum_1.default.Null || type === null;
+        }
+        static _fetchJsonData(response) {
+            return __awaiter(this, void 0, void 0, function* () {
+                try {
+                    return yield response.json();
+                }
+                catch (error) {
+                    const err = ErrorHelper_1.default.getError(error);
+                    throw new Error(`Could not load json data from response. ${err.message}`);
+                }
+            });
+        }
+        static _fetchFileData(response) {
+            return __awaiter(this, void 0, void 0, function* () {
+                try {
+                    return yield response.blob();
+                }
+                catch (error) {
+                    const err = ErrorHelper_1.default.getError(error);
+                    throw new Error(`Could not load json data from response. ${err.message}`);
+                }
+            });
+        }
+        static _fetchTextData(response) {
+            return __awaiter(this, void 0, void 0, function* () {
+                try {
+                    return yield response.text();
+                }
+                catch (error) {
+                    const err = ErrorHelper_1.default.getError(error);
+                    throw new Error(`Could not load text data from response. ${err.message}`);
+                }
+            });
+        }
+    }
+    HttpClientHelper.FULL_URL_PATTERN = /^https?:\/\//i;
+    HttpClientHelper.NOT_AUTHENTICATED_ERROR_NAME = "RESPONSE_NOT_AUTHENTICATED";
+    /**
+     * @description Check if error is not authenticated
+     * @param error
+     * @returns
+     */
+    HttpClientHelper.isNotAuthenticated = (error) => error.name === HttpClientHelper.NOT_AUTHENTICATED_ERROR_NAME;
+    exports.default = HttpClientHelper;
+});

package/dist-amd/helpers/NavigationHelper.d.ts

@@ -0,0 +1,52 @@
+/**
+ * Helper for navigating from UIAPI Web Client extensions to AppEngine plugin routes.
+ *
+ * AppEngine plugins are opened via the Web Client hash URL format:
+ * `#webclient-CompuTecWebClientStart-CompuTecWebClientStart&/{pluginId},{route}/{pluginName}`
+ *
+ * Routes containing path separators (e.g. `ctp/4/0`) must be double-encoded
+ * so that both the browser and the SAPUI5 router decode them correctly.
+ */
+export default class NavigationHelper {
+    private static readonly HASH_PREFIX;
+    /**
+     * Build the full Web Client hash URL for navigating to an AppEngine plugin route.
+     *
+     * @param pluginId  The plugin identifier (e.g. `"MRP"`)
+     * @param route     The SAPUI5 route path including parameters (e.g. `"ctp/4/0"`, `"wizard"`)
+     * @param pluginName Optional display name; defaults to `pluginId`
+     * @returns The complete hash URL string
+     *
+     * @example
+     * ```typescript
+     * NavigationHelper.buildPluginUrl("MRP", "ctp/4/0");
+     * // => "#webclient-CompuTecWebClientStart-CompuTecWebClientStart&/MRP,ctp%252F4%252F0/MRP"
+     *
+     * NavigationHelper.buildPluginUrl("MRP", "wizard");
+     * // => "#webclient-CompuTecWebClientStart-CompuTecWebClientStart&/MRP,wizard/MRP"
+     * ```
+     */
+    static buildPluginUrl(pluginId: string, route: string, pluginName?: string): string;
+    /**
+     * Navigate to an AppEngine plugin route using the SDKEnv `open` method.
+     *
+     * @param openFn    A function that opens a URL — typically `oEnv.open.bind(oEnv)` or `(url) => oEnv.open(url)`
+     * @param pluginId  The plugin identifier (e.g. `"MRP"`)
+     * @param route     The SAPUI5 route path including parameters (e.g. `"ctp/4/0"`)
+     * @param pluginName Optional display name; defaults to `pluginId`
+     *
+     * @example
+     * ```typescript
+     * // In a UIAPI controller:
+     * import { NavigationHelper } from "@computec/uibase";
+     *
+     * await NavigationHelper.openPlugin(
+     *     (url) => oEnv.open(url),
+     *     "MRP",
+     *     `ctp/${docEntry}/${lineNum}`
+     * );
+     * ```
+     */
+    static openPlugin(openFn: (url: string) => Promise<void>, pluginId: string, route: string, pluginName?: string): Promise<void>;
+}
+//# sourceMappingURL=NavigationHelper.d.ts.map

package/dist-amd/helpers/NavigationHelper.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"NavigationHelper.d.ts","sourceRoot":"","sources":["../../src/helpers/NavigationHelper.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AACH,MAAM,CAAC,OAAO,OAAO,gBAAgB;IACpC,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAC,WAAW,CACyB;IAE5D;;;;;;;;;;;;;;;;OAgBG;WACW,cAAc,CAC3B,QAAQ,EAAE,MAAM,EAChB,KAAK,EAAE,MAAM,EACb,UAAU,CAAC,EAAE,MAAM,GACjB,MAAM;IAKT;;;;;;;;;;;;;;;;;;;OAmBG;WACiB,UAAU,CAC7B,MAAM,EAAE,CAAC,GAAG,EAAE,MAAM,KAAK,OAAO,CAAC,IAAI,CAAC,EACtC,QAAQ,EAAE,MAAM,EAChB,KAAK,EAAE,MAAM,EACb,UAAU,CAAC,EAAE,MAAM,GACjB,OAAO,CAAC,IAAI,CAAC;CAIhB"}

package/dist-amd/helpers/NavigationHelper.js

@@ -0,0 +1,73 @@
+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());
+    });
+};
+define(["require", "exports"], function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    /**
+     * Helper for navigating from UIAPI Web Client extensions to AppEngine plugin routes.
+     *
+     * AppEngine plugins are opened via the Web Client hash URL format:
+     * `#webclient-CompuTecWebClientStart-CompuTecWebClientStart&/{pluginId},{route}/{pluginName}`
+     *
+     * Routes containing path separators (e.g. `ctp/4/0`) must be double-encoded
+     * so that both the browser and the SAPUI5 router decode them correctly.
+     */
+    class NavigationHelper {
+        /**
+         * Build the full Web Client hash URL for navigating to an AppEngine plugin route.
+         *
+         * @param pluginId  The plugin identifier (e.g. `"MRP"`)
+         * @param route     The SAPUI5 route path including parameters (e.g. `"ctp/4/0"`, `"wizard"`)
+         * @param pluginName Optional display name; defaults to `pluginId`
+         * @returns The complete hash URL string
+         *
+         * @example
+         * ```typescript
+         * NavigationHelper.buildPluginUrl("MRP", "ctp/4/0");
+         * // => "#webclient-CompuTecWebClientStart-CompuTecWebClientStart&/MRP,ctp%252F4%252F0/MRP"
+         *
+         * NavigationHelper.buildPluginUrl("MRP", "wizard");
+         * // => "#webclient-CompuTecWebClientStart-CompuTecWebClientStart&/MRP,wizard/MRP"
+         * ```
+         */
+        static buildPluginUrl(pluginId, route, pluginName) {
+            const encodedRoute = encodeURIComponent(encodeURIComponent(route));
+            return `${NavigationHelper.HASH_PREFIX}&/${pluginId},${encodedRoute}/${pluginName !== null && pluginName !== void 0 ? pluginName : pluginId}`;
+        }
+        /**
+         * Navigate to an AppEngine plugin route using the SDKEnv `open` method.
+         *
+         * @param openFn    A function that opens a URL — typically `oEnv.open.bind(oEnv)` or `(url) => oEnv.open(url)`
+         * @param pluginId  The plugin identifier (e.g. `"MRP"`)
+         * @param route     The SAPUI5 route path including parameters (e.g. `"ctp/4/0"`)
+         * @param pluginName Optional display name; defaults to `pluginId`
+         *
+         * @example
+         * ```typescript
+         * // In a UIAPI controller:
+         * import { NavigationHelper } from "@computec/uibase";
+         *
+         * await NavigationHelper.openPlugin(
+         *     (url) => oEnv.open(url),
+         *     "MRP",
+         *     `ctp/${docEntry}/${lineNum}`
+         * );
+         * ```
+         */
+        static openPlugin(openFn, pluginId, route, pluginName) {
+            return __awaiter(this, void 0, void 0, function* () {
+                const url = NavigationHelper.buildPluginUrl(pluginId, route, pluginName);
+                yield openFn(url);
+            });
+        }
+    }
+    NavigationHelper.HASH_PREFIX = "#webclient-CompuTecWebClientStart-CompuTecWebClientStart";
+    exports.default = NavigationHelper;
+});