@ibm-aspera/sdk 0.2.29 → 0.2.30

package/dist/commonjs/helpers/client/safari-client.js

@@ -0,0 +1,264 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.safariClient = exports.SafariClient = void 0;
+var helpers_1 = require("../helpers");
+var index_1 = require("../../index");
+/**
+ * Enum defining different types of Safari extension events.
+ */
+var SafariExtensionEventType;
+(function (SafariExtensionEventType) {
+    SafariExtensionEventType["Monitor"] = "Monitor";
+    SafariExtensionEventType["Ping"] = "Ping";
+    SafariExtensionEventType["Request"] = "Request";
+})(SafariExtensionEventType || (SafariExtensionEventType = {}));
+/**
+ * Global keep alive timeout to prevent recursion.
+ */
+var keepAliveTimeout;
+/**
+ * Handles communication with the Safari extension using JSON-RPC over custom events.
+ */
+var SafariClient = /** @class */ (function () {
+    /**
+     * Initializes the SafariExtensionHandler instance.
+     * Sets up the promise executor map and starts listening to extension events.
+     */
+    function SafariClient() {
+        var _this = this;
+        this.keepAliveInterval = 1000;
+        this.lastPing = null;
+        this.lastPong = null;
+        this.safariExtensionEnabled = false;
+        this.subscribedTransferActivity = false;
+        /**
+         * Sends a JSON-RPC request to the Safari extension.
+         * @param method The method name to invoke on the extension.
+         * @param payload Optional payload for the request.
+         * @returns A Promise that resolves with the response from the extension.
+         */
+        this.request = function (method, payload) {
+            if (payload === void 0) { payload = {}; }
+            return _this.dispatchPromiseEvent(SafariExtensionEventType.Request, method, payload);
+        };
+        this.promiseExecutors = new Map();
+        this.listenResponseEvents();
+        this.listenTransferActivityEvents();
+        this.listenStatusEvents();
+        this.listenClientStatusEvents();
+        this.listenPongEvents();
+        if (keepAliveTimeout) {
+            clearTimeout(keepAliveTimeout);
+        }
+        this.keepAlive();
+    }
+    /**
+     * Monitors transfer activity.
+     * @returns A Promise that resolves with the response from the extension.
+     */
+    SafariClient.prototype.monitorTransferActivity = function () {
+        var _this = this;
+        var dispatchMonitorEvent = function () {
+            var promise = _this.dispatchPromiseEvent(SafariExtensionEventType.Monitor, 'subscribe_transfer_activity', [index_1.asperaSdk.globals.appId]);
+            return promise.then(function () {
+                _this.subscribedTransferActivity = true;
+            });
+        };
+        if (this.safariExtensionEnabled) {
+            return dispatchMonitorEvent();
+        }
+        return new Promise(function (resolve, reject) {
+            var extensionInterval = setInterval(function () {
+                if (!_this.safariExtensionEnabled) {
+                    return;
+                }
+                dispatchMonitorEvent()
+                    .then(resolve)
+                    .catch(reject);
+                clearInterval(extensionInterval);
+            }, 1000);
+        });
+    };
+    /**
+     * Builds a JSON-RPC request object with a unique identifier.
+     * @param method The method name to invoke on the extension.
+     * @param payload Optional parameters for the method.
+     * @returns The constructed JSON-RPC request object.
+     */
+    SafariClient.prototype.buildRPCRequest = function (method, payload) {
+        return {
+            jsonrpc: '2.0',
+            method: method,
+            params: payload,
+            id: (0, helpers_1.randomUUID)()
+        };
+    };
+    /**
+     * Dispatches a custom event to the document to communicate with the Safari extension.
+     * @param type The type of Safari extension event to dispatch.
+     * @param request Optional JSON-RPC request payload to send with the event.
+     */
+    SafariClient.prototype.dispatchEvent = function (type, request) {
+        var payload = {
+            detail: request !== null && request !== void 0 ? request : {}
+        };
+        document.dispatchEvent(new CustomEvent("AsperaDesktop.".concat(type), payload));
+    };
+    /**
+     * Dispatches a custom event to the document to communicate with the Safari extension.
+     * @param type The type of Safari extension event to dispatch.
+     * @param method The method name to invoke on the extension.
+     * @param payload Optional parameters for the method.
+     */
+    SafariClient.prototype.dispatchPromiseEvent = function (type, method, payload) {
+        var _this = this;
+        var request = this.buildRPCRequest(method, payload);
+        return new Promise(function (resolve, reject) {
+            if (_this.safariExtensionEnabled) {
+                _this.promiseExecutors.set(request.id, { resolve: resolve, reject: reject });
+                _this.dispatchEvent(type, request);
+            }
+            else {
+                console.warn('The Safari extension is disabled or unresponsive (dispatch event)');
+                console.warn("Failed event: ".concat((0, helpers_1.safeJsonString)(request)));
+                reject('The Safari extension is disabled or unresponsive (dispatch event)');
+            }
+        });
+    };
+    /**
+     * Handles incoming JSON-RPC responses from the Safari extension.
+     * Resolves or rejects promises based on the response.
+     * @param response The JSON-RPC response object received from the extension.
+     */
+    SafariClient.prototype.handleResponse = function (response) {
+        var requestId = response.id;
+        var executor = this.promiseExecutors.get(requestId);
+        if (!executor) {
+            console.warn("Unable to find a promise executor for ".concat(requestId));
+            console.warn("Response: ".concat(response));
+            return;
+        }
+        this.promiseExecutors.delete(requestId);
+        if (response.error) {
+            executor.reject(response.error);
+            return;
+        }
+        executor.resolve(response.result);
+    };
+    /**
+     * Listens for 'AsperaDesktop.Response' events.
+     */
+    SafariClient.prototype.listenResponseEvents = function () {
+        var _this = this;
+        document.addEventListener('AsperaDesktop.Response', function (event) {
+            if (!event.detail) {
+                return;
+            }
+            _this.handleResponse(event.detail);
+        });
+    };
+    /**
+     * Listens for 'AsperaDesktop.TransferActivity' events.
+     */
+    SafariClient.prototype.listenTransferActivityEvents = function () {
+        document.addEventListener('AsperaDesktop.TransferActivity', function (event) {
+            if (!event.detail) {
+                return;
+            }
+            index_1.asperaSdk.activityTracking.handleTransferActivity(event.detail);
+        });
+    };
+    /**
+     * Listens for 'AsperaDesktop.Status' events.
+     */
+    SafariClient.prototype.listenStatusEvents = function () {
+        document.addEventListener('AsperaDesktop.Status', function (event) {
+            if (!event.detail) {
+                return;
+            }
+            index_1.asperaSdk.activityTracking.handleWebSocketEvents(event.detail);
+        });
+    };
+    /**
+     * Listens for 'isAppAlive' events. This was introduced in version 1.0.9.
+     */
+    SafariClient.prototype.listenClientStatusEvents = function () {
+        document.addEventListener('isAppAlive', function (event) {
+            var _a;
+            if (!((_a = event.detail) === null || _a === void 0 ? void 0 : _a.running)) {
+                return;
+            }
+            index_1.asperaSdk.activityTracking.handleClientEvents(event.detail.running);
+        });
+    };
+    /**
+     * Listens for 'AsperaDesktop.Pong' events.
+     */
+    SafariClient.prototype.listenPongEvents = function () {
+        var _this = this;
+        document.addEventListener('AsperaDesktop.Pong', function () {
+            _this.lastPong = Date.now();
+            _this.safariExtensionStatusChanged(true);
+        });
+    };
+    /**
+     * Sends a keep alive ping according to the defined interval.
+     */
+    SafariClient.prototype.keepAlive = function () {
+        var _this = this;
+        this.lastPing = Date.now();
+        this.dispatchEvent(SafariExtensionEventType.Ping);
+        keepAliveTimeout = setTimeout(function () {
+            _this.keepAlive();
+        }, this.keepAliveInterval);
+    };
+    /**
+     * Listens for Safari extension status changes.
+     * If the extension was disabled and enabled again after initializing the SDK, it
+     * will call 'monitorTransferActivity' to resume transfer activities.
+     */
+    SafariClient.prototype.safariExtensionStatusChanged = function (isEnabled) {
+        var _this = this;
+        if (isEnabled === this.safariExtensionEnabled) {
+            return;
+        }
+        this.safariExtensionEnabled = isEnabled;
+        if (isEnabled) {
+            if (this.subscribedTransferActivity) {
+                var resumeTransferActivity_1 = function () {
+                    _this.monitorTransferActivity()
+                        .catch(function () {
+                        console.error('Failed to resume transfer activity, will try again in 1s');
+                        setTimeout(function () {
+                            resumeTransferActivity_1();
+                        }, 1000);
+                    });
+                };
+                resumeTransferActivity_1();
+            }
+        }
+        else {
+            index_1.asperaSdk.activityTracking.handleWebSocketEvents('CLOSED');
+            this.promiseExecutors.forEach(function (promiseExecutor) {
+                promiseExecutor.reject('The Safari extension is disabled or unresponsive (extension status)');
+            });
+            this.promiseExecutors.clear();
+        }
+        index_1.asperaSdk.activityTracking.handleSafariExtensionEvents(this.safariExtensionEnabled ? 'ENABLED' : 'DISABLED');
+    };
+    /**
+     * Checks if the last pong received was longer than the max interval.
+     */
+    SafariClient.prototype.checkSafariExtensionStatus = function () {
+        var pingPongDiff = this.lastPong - this.lastPing;
+        if (this.lastPong == null || pingPongDiff < 0 || pingPongDiff > 500) {
+            this.safariExtensionStatusChanged(false);
+        }
+    };
+    return SafariClient;
+}());
+exports.SafariClient = SafariClient;
+exports.safariClient = new SafariClient();
+exports.default = {
+    safariClient: exports.safariClient
+};

package/dist/commonjs/helpers/helpers.d.ts

@@ -0,0 +1,109 @@
+import { ErrorResponse, InstallerUrlInfo, PromiseObject, TransferSpec } from '../models/models';
+/**
+ * Generates promise object that can be resolved or rejected via functions
+ *
+ * @returns an object containing the promise, the resolver and rejecter
+ */
+export declare const generatePromiseObjects: () => PromiseObject;
+/**
+ * Log errors from Aspera SDK
+ *
+ * @param message the message indicating the error encountered
+ * @param debugData the data with useful debugging information
+ */
+export declare const errorLog: (message: string, debugData?: any) => void;
+/**
+ * Generate error object for rejecter responses
+ *
+ * @param message the message indicating the error encountered
+ * @param debugData the data with useful debugging information
+ *
+ * @returns object containing standardized error response
+ */
+export declare const generateErrorBody: (message: string, debugData?: any) => ErrorResponse;
+/**
+ * Validate if transferSpec is valid for server communication
+ *
+ * @param transferSpec the transferSpec to test
+ *
+ * @returns boolean indicating whether supplied transferSpec is valid
+ */
+export declare const isValidTransferSpec: (transferSpec: TransferSpec) => boolean;
+/**
+ * Returns a string indicating the websocket URL to use for talking to the server
+ *
+ * @returns a string of the full Websocket URL
+ */
+export declare const getWebsocketUrl: (serverUrl: string) => string;
+/**
+ * Simple function to get the current platform.
+ *
+ * @returns a string indicating the current platform
+ */
+export declare const getCurrentPlatform: () => "macos" | "windows" | "linux" | "unknown";
+/**
+ * Function used to create a random UUID
+ *
+ * @returns string
+ */
+export declare const randomUUID: () => string;
+/**
+ * Return a rejected promise
+ *
+ * @param message the message indicating the error encountered
+ * @param debugData the data with useful debugging information
+ *
+ * @returns a rejected promise
+ */
+export declare const throwError: (message: string, debugData?: any) => Promise<any>;
+/**
+ * Check if the given string is a valid URL
+ *
+ * @param url string to check if valid URL
+ *
+ * @returns boolean
+ */
+export declare const isValidURL: (url: string) => boolean;
+/**
+ * Checks if the current browser is Safari.
+ * @returns {boolean} Whether the browser is Safari.
+ */
+export declare const isSafari: () => boolean;
+/**
+ * Get the URLs for installer management.
+ *
+ * @returns Info on URLs where installers live
+ */
+export declare const getInstallerUrls: () => InstallerUrlInfo;
+/**
+ * Try to stringify a JSON string and log failures
+ *
+ * @param json - Object to make into a string
+ *
+ * @returns string representing JSON or empty string on error
+ */
+export declare const safeJsonString: (json: unknown) => string;
+/**
+ * Try to parse a JSON string and log failures
+ *
+ * @param json - String to make into an object
+ *
+ * @returns object or array from the JSON string. Or undefined
+ */
+export declare const safeJsonParse: (json: string) => any | undefined;
+declare const _default: {
+    errorLog: (message: string, debugData?: any) => void;
+    generateErrorBody: (message: string, debugData?: any) => ErrorResponse;
+    generatePromiseObjects: () => PromiseObject;
+    getCurrentPlatform: () => "macos" | "windows" | "linux" | "unknown";
+    getWebsocketUrl: (serverUrl: string) => string;
+    isSafari: () => boolean;
+    isValidURL: (url: string) => boolean;
+    isValidTransferSpec: (transferSpec: TransferSpec) => boolean;
+    randomUUID: () => string;
+    throwError: (message: string, debugData?: any) => Promise<any>;
+    getInstallerUrls: () => InstallerUrlInfo;
+    safeJsonString: (json: unknown) => string;
+    safeJsonParse: (json: string) => any | undefined;
+};
+export default _default;

package/dist/commonjs/helpers/helpers.js

@@ -0,0 +1,249 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.safeJsonParse = exports.safeJsonString = exports.getInstallerUrls = exports.isSafari = exports.isValidURL = exports.throwError = exports.randomUUID = exports.getCurrentPlatform = exports.getWebsocketUrl = exports.isValidTransferSpec = exports.generateErrorBody = exports.errorLog = exports.generatePromiseObjects = void 0;
+var constants_1 = require("../constants/constants");
+/**
+ * Generates promise object that can be resolved or rejected via functions
+ *
+ * @returns an object containing the promise, the resolver and rejecter
+ */
+var generatePromiseObjects = function () {
+    var resolver;
+    var rejecter;
+    var promise = new Promise(function (resolve, reject) {
+        resolver = resolve;
+        rejecter = reject;
+    });
+    return {
+        promise: promise,
+        resolver: resolver,
+        rejecter: rejecter
+    };
+};
+exports.generatePromiseObjects = generatePromiseObjects;
+/**
+ * Log errors from Aspera SDK
+ *
+ * @param message the message indicating the error encountered
+ * @param debugData the data with useful debugging information
+ */
+var errorLog = function (message, debugData) {
+    if (debugData && debugData.code && debugData.message) {
+        debugData = {
+            code: debugData.code,
+            message: debugData.message,
+            data: debugData.data
+        };
+    }
+    if (typeof window === 'object') {
+        if (!Array.isArray(window.asperaSdkLogs)) {
+            window.asperaSdkLogs = [];
+        }
+        window.asperaSdkLogs.push({ message: message, debugData: debugData });
+    }
+    console.warn("Aspera SDK: ".concat(message), debugData);
+};
+exports.errorLog = errorLog;
+/**
+ * Generate error object for rejecter responses
+ *
+ * @param message the message indicating the error encountered
+ * @param debugData the data with useful debugging information
+ *
+ * @returns object containing standardized error response
+ */
+var generateErrorBody = function (message, debugData) {
+    var errorResponse = {
+        error: true,
+        message: message
+    };
+    if (debugData && debugData.code && debugData.message) {
+        errorResponse.debugData = {
+            code: debugData.code,
+            message: debugData.message,
+            data: debugData.data
+        };
+    }
+    return errorResponse;
+};
+exports.generateErrorBody = generateErrorBody;
+/**
+ * Validate if transferSpec is valid for server communication
+ *
+ * @param transferSpec the transferSpec to test
+ *
+ * @returns boolean indicating whether supplied transferSpec is valid
+ */
+var isValidTransferSpec = function (transferSpec) {
+    if (transferSpec &&
+        typeof transferSpec === 'object' &&
+        typeof transferSpec.direction === 'string' &&
+        typeof transferSpec.remote_host === 'string' &&
+        Array.isArray(transferSpec.paths)) {
+        return true;
+    }
+    return false;
+};
+exports.isValidTransferSpec = isValidTransferSpec;
+/**
+ * Returns a string indicating the websocket URL to use for talking to the server
+ *
+ * @returns a string of the full Websocket URL
+ */
+var getWebsocketUrl = function (serverUrl) {
+    var wsProtocol;
+    if (serverUrl.indexOf('http:') === 0) {
+        wsProtocol = 'ws';
+    }
+    else if (serverUrl.indexOf('https:') === 0) {
+        wsProtocol = 'wss';
+    }
+    var url = serverUrl.replace('http://', '//').replace('https://', '//');
+    return "".concat(wsProtocol, ":").concat(url);
+};
+exports.getWebsocketUrl = getWebsocketUrl;
+/**
+ * Simple function to get the current platform.
+ *
+ * @returns a string indicating the current platform
+ */
+var getCurrentPlatform = function () {
+    var ua = navigator.userAgent;
+    if (/Mac/.test(ua)) {
+        return 'macos';
+    }
+    else if (/Win/.test(ua)) {
+        return 'windows';
+    }
+    else if (/Linux/.test(ua)) {
+        return 'linux';
+    }
+    else {
+        return 'unknown';
+    }
+};
+exports.getCurrentPlatform = getCurrentPlatform;
+/**
+ * Function used to create a random UUID
+ *
+ * @returns string
+ */
+var randomUUID = function () {
+    var _a;
+    var fallback = function () {
+        return 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, function (c) {
+            var r = Number(((new Date().getTime() + 16) * Math.random()).toFixed()) % 16;
+            if (c !== 'x') {
+                // eslint-disable-next-line no-bitwise
+                r = r & 0x3 | 0x8;
+            }
+            return r.toString(16);
+        });
+    };
+    return ((_a = window.crypto) === null || _a === void 0 ? void 0 : _a.randomUUID) ? window.crypto.randomUUID() : fallback();
+};
+exports.randomUUID = randomUUID;
+/**
+ * Return a rejected promise
+ *
+ * @param message the message indicating the error encountered
+ * @param debugData the data with useful debugging information
+ *
+ * @returns a rejected promise
+ */
+var throwError = function (message, debugData) {
+    (0, exports.errorLog)(message, debugData);
+    return new Promise(function (resolve, reject) {
+        reject((0, exports.generateErrorBody)(message, debugData));
+    });
+};
+exports.throwError = throwError;
+/**
+ * Check if the given string is a valid URL
+ *
+ * @param url string to check if valid URL
+ *
+ * @returns boolean
+ */
+var isValidURL = function (url) {
+    try {
+        new URL(url);
+        return true;
+    }
+    catch (error) {
+        return false;
+    }
+};
+exports.isValidURL = isValidURL;
+/**
+ * Checks if the current browser is Safari.
+ * @returns {boolean} Whether the browser is Safari.
+ */
+var isSafari = function () {
+    return /^((?!chrome|android).)*safari/i.test(navigator.userAgent) && !window.MSStream;
+};
+exports.isSafari = isSafari;
+/**
+ * Get the URLs for installer management.
+ *
+ * @returns Info on URLs where installers live
+ */
+var getInstallerUrls = function () {
+    return {
+        base: constants_1.baseInstallerUrl,
+        latest: constants_1.installerUrl,
+    };
+};
+exports.getInstallerUrls = getInstallerUrls;
+/**
+ * Try to stringify a JSON string and log failures
+ *
+ * @param json - Object to make into a string
+ *
+ * @returns string representing JSON or empty string on error
+ */
+var safeJsonString = function (json) {
+    try {
+        return JSON.stringify(json);
+    }
+    catch (error) {
+        (0, exports.errorLog)('safeJsonString: unable to stringify JSON', { error: error, json: json });
+        return '';
+    }
+};
+exports.safeJsonString = safeJsonString;
+/**
+ * Try to parse a JSON string and log failures
+ *
+ * @param json - String to make into an object
+ *
+ * @returns object or array from the JSON string. Or undefined
+ */
+var safeJsonParse = function (json) {
+    if (json && typeof json === 'object') {
+        return json;
+    }
+    try {
+        return JSON.parse(json);
+    }
+    catch (error) {
+        (0, exports.errorLog)('safeJsonParse: unable to parse JSON', { error: error, json: json });
+        return undefined;
+    }
+};
+exports.safeJsonParse = safeJsonParse;
+exports.default = {
+    errorLog: exports.errorLog,
+    generateErrorBody: exports.generateErrorBody,
+    generatePromiseObjects: exports.generatePromiseObjects,
+    getCurrentPlatform: exports.getCurrentPlatform,
+    getWebsocketUrl: exports.getWebsocketUrl,
+    isSafari: exports.isSafari,
+    isValidURL: exports.isValidURL,
+    isValidTransferSpec: exports.isValidTransferSpec,
+    randomUUID: exports.randomUUID,
+    throwError: exports.throwError,
+    getInstallerUrls: exports.getInstallerUrls,
+    safeJsonString: exports.safeJsonString,
+    safeJsonParse: exports.safeJsonParse,
+};

package/dist/commonjs/helpers/http.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Check HTTP promise response for server error response (non 2XX status) and reject promise is error
+ *
+ * @param promise the HTTP promise to check for HTTP status code of 2XX for success
+ *
+ * @returns promise for the HTTP connection with catch supporting error
+ */
+export declare const handlePromiseErrors: (promise: Promise<any>) => Promise<any>;
+/**
+ * Make a GET for retrieving data from a server
+ *
+ * @param url the url string of the resource on the server
+ *
+ * @returns a promise that will resolve with the response from the server or reject if network/server error
+ */
+export declare const apiGet: (url: string) => Promise<any>;

package/dist/commonjs/helpers/http.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.apiGet = exports.handlePromiseErrors = void 0;
+var helpers_1 = require("./helpers");
+/**
+ * Check HTTP promise response for server error response (non 2XX status) and reject promise is error
+ *
+ * @param promise the HTTP promise to check for HTTP status code of 2XX for success
+ *
+ * @returns promise for the HTTP connection with catch supporting error
+ */
+var handlePromiseErrors = function (promise) {
+    var promiseInfo = (0, helpers_1.generatePromiseObjects)();
+    promise.then(function (response) {
+        if (response.ok) {
+            promiseInfo.resolver(response);
+        }
+        else {
+            promiseInfo.rejecter(response);
+        }
+        return response;
+    }).catch(function (error) {
+        promiseInfo.rejecter(error);
+    });
+    return promiseInfo.promise;
+};
+exports.handlePromiseErrors = handlePromiseErrors;
+/**
+ * Make a GET for retrieving data from a server
+ *
+ * @param url the url string of the resource on the server
+ *
+ * @returns a promise that will resolve with the response from the server or reject if network/server error
+ */
+var apiGet = function (url) {
+    return (0, exports.handlePromiseErrors)(fetch(url, {
+        headers: {
+            'Content-Type': 'application/json',
+        },
+    }));
+};
+exports.apiGet = apiGet;