@ibm-aspera/sdk 0.2.2

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

@@ -0,0 +1,5 @@
+interface Client {
+    request(method: String, payload?: any): Promise<any>;
+}
+export declare const client: Client;
+export default Client;

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

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.client = void 0;
+var http_client_1 = require("./http-client");
+var safari_client_1 = require("./safari-client");
+var helpers_1 = require("../helpers");
+exports.client = (0, helpers_1.isSafari)() ? safari_client_1.safariClient : http_client_1.httpClient;

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

@@ -0,0 +1,42 @@
+import { JSONRPCClient } from 'json-rpc-2.0';
+import Client from './client';
+export declare const getRpcServerUrl: () => string;
+/**
+ * Wraps a promise like object and returns a promise that supports catch.
+ *
+ * @param promise the HTTP promise like to wrap
+ *
+ * @returns promise for the HTTP connection with catch supporting error
+ */
+export declare const handlePromiseLikeErrors: (promise: PromiseLike<any>) => Promise<any>;
+/**
+ * JSON RPC client using HTTP (fetch) as transport.
+ */
+declare class JSONRPCHttpClient {
+    /** JSON-RPC client used to make requests */
+    client: JSONRPCClient;
+    constructor();
+    /**
+     * Request handler for the JSON-RPC client. This function is called by the JSON-RPC library
+     * after forming the RPC request.
+     *
+     * @param request JSON-RPC request to send to the server
+     */
+    private handleRequest;
+    request: (method: string, data: any) => PromiseLike<any>;
+}
+/**
+ * Client used for making requests to Aspera.
+ */
+declare class HttpClient implements Client {
+    /** HTTP client used to make requests */
+    httpClient: JSONRPCHttpClient;
+    constructor();
+    request: (method: string, payload?: any) => Promise<any>;
+}
+export declare const httpClient: HttpClient;
+declare const _default: {
+    httpClient: HttpClient;
+    handlePromiseLikeErrors: (promise: PromiseLike<any>) => Promise<any>;
+};
+export default _default;

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

@@ -0,0 +1,84 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.httpClient = exports.handlePromiseLikeErrors = exports.getRpcServerUrl = void 0;
+var json_rpc_2_0_1 = require("json-rpc-2.0");
+var helpers_1 = require("../helpers");
+var index_1 = require("../../index");
+var getRpcServerUrl = function () {
+    return "".concat(index_1.asperaSdk.globals.asperaAppUrl, ":").concat(index_1.asperaSdk.globals.rpcPort);
+};
+exports.getRpcServerUrl = getRpcServerUrl;
+/**
+ * Wraps a promise like object and returns a promise that supports catch.
+ *
+ * @param promise the HTTP promise like to wrap
+ *
+ * @returns promise for the HTTP connection with catch supporting error
+ */
+var handlePromiseLikeErrors = function (promise) {
+    var promiseInfo = (0, helpers_1.generatePromiseObjects)();
+    promise.then(function (response) {
+        promiseInfo.resolver(response);
+    }, function (error) {
+        promiseInfo.rejecter(error);
+    });
+    return promiseInfo.promise;
+};
+exports.handlePromiseLikeErrors = handlePromiseLikeErrors;
+/**
+ * JSON RPC client using HTTP (fetch) as transport.
+ */
+var JSONRPCHttpClient = /** @class */ (function () {
+    function JSONRPCHttpClient() {
+        var _this = this;
+        /**
+         * Request handler for the JSON-RPC client. This function is called by the JSON-RPC library
+         * after forming the RPC request.
+         *
+         * @param request JSON-RPC request to send to the server
+         */
+        this.handleRequest = function (request) {
+            var options = {
+                method: 'POST',
+                headers: {
+                    'content-type': 'application/json',
+                },
+                body: JSON.stringify(request),
+            };
+            var rpcServerURL = (0, exports.getRpcServerUrl)();
+            return fetch(rpcServerURL, options).then(function (response) {
+                if (response.ok) {
+                    return response.json().then(function (rpcResponse) { return _this.client.receive(rpcResponse); });
+                }
+                else if (request.id !== undefined) {
+                    throw Promise.reject(response.statusText);
+                }
+            });
+        };
+        this.request = function (method, data) {
+            return _this.client.request(method, data);
+        };
+        this.client = new json_rpc_2_0_1.JSONRPCClient(this.handleRequest);
+    }
+    return JSONRPCHttpClient;
+}());
+/**
+ * Client used for making requests to Aspera.
+ */
+var HttpClient = /** @class */ (function () {
+    function HttpClient() {
+        var _this = this;
+        this.request = function (method, payload) {
+            if (payload === void 0) { payload = {}; }
+            return (0, exports.handlePromiseLikeErrors)(_this.httpClient.request(method, payload));
+        };
+        this.httpClient = new JSONRPCHttpClient();
+    }
+    ;
+    return HttpClient;
+}());
+exports.httpClient = new HttpClient();
+exports.default = {
+    httpClient: exports.httpClient,
+    handlePromiseLikeErrors: exports.handlePromiseLikeErrors,
+};

package/dist/commonjs/helpers/client/safari-client.d.ts

@@ -0,0 +1,99 @@
+import Client from './client';
+/**
+ * Interface representing a promise executor used in a promise.
+ */
+export interface PromiseExecutor {
+    resolve: (value: any) => void;
+    reject: (error: any) => void;
+}
+/**
+ * Handles communication with the Safari extension using JSON-RPC over custom events.
+ */
+export declare class SafariClient implements Client {
+    private statusInterval;
+    private keepAliveInterval;
+    private promiseExecutors;
+    private isFirstPing;
+    private lastPing;
+    private lastPong;
+    private safariExtensionEnabled;
+    private subscribedTransferActivity;
+    /**
+     * Initializes the SafariExtensionHandler instance.
+     * Sets up the promise executor map and starts listening to extension events.
+     */
+    constructor();
+    /**
+     * 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.
+     */
+    request: (method: string, payload?: any) => Promise<any>;
+    /**
+     * Monitors transfer activity.
+     * @returns A Promise that resolves with the response from the extension.
+     */
+    monitorTransferActivity(): Promise<unknown>;
+    /**
+     * 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.
+     */
+    private buildRPCRequest;
+    /**
+     * 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.
+     */
+    private dispatchEvent;
+    /**
+     * 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.
+     */
+    private dispatchPromiseEvent;
+    /**
+     * 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.
+     */
+    private handleResponse;
+    /**
+     * Listens for 'AsperaDesktop.Response' events.
+     */
+    private listenResponseEvents;
+    /**
+     * Listens for 'AsperaDesktop.TransferActivity' events.
+     */
+    private listenTransferActivityEvents;
+    /**
+     * Listens for 'AsperaDesktop.Status' events.
+     */
+    private listenStatusEvents;
+    /**
+     * Listens for 'AsperaDesktop.Pong' events.
+     */
+    private listenPongEvents;
+    /**
+     * Sends a keep alive ping according to the defined interval.
+     */
+    private keepAlive;
+    /**
+     * 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.
+     */
+    private safariExtensionStatusChanged;
+    /**
+     * Checks if the last pong received was longer than the max interval.
+     */
+    private checkSafariExtensionStatus;
+}
+export declare const safariClient: SafariClient;
+declare const _default: {
+    safariClient: SafariClient;
+};
+export default _default;

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

@@ -0,0 +1,252 @@
+"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.statusInterval = 100;
+        this.keepAliveInterval = 1000;
+        this.isFirstPing = true;
+        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.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(JSON.stringify(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) {
+            _this.handleResponse(event.detail);
+        });
+    };
+    /**
+     * Listens for 'AsperaDesktop.TransferActivity' events.
+     */
+    SafariClient.prototype.listenTransferActivityEvents = function () {
+        document.addEventListener('AsperaDesktop.TransferActivity', function (event) {
+            index_1.asperaSdk.activityTracking.handleTransferActivity(event.detail);
+        });
+    };
+    /**
+     * Listens for 'AsperaDesktop.Status' events.
+     */
+    SafariClient.prototype.listenStatusEvents = function () {
+        document.addEventListener('AsperaDesktop.Status', function (event) {
+            index_1.asperaSdk.activityTracking.handleWebSocketEvents(event.detail);
+        });
+    };
+    /**
+     * 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);
+        if (this.isFirstPing) {
+            this.isFirstPing = false;
+        }
+        else {
+            setTimeout(function () {
+                _this.checkSafariExtensionStatus();
+            }, this.statusInterval);
+        }
+        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,84 @@
+import { ErrorResponse, 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;
+declare const _default: {
+    errorLog: (message: string, debugData?: any) => void;
+    generateErrorBody: (message: string, debugData?: any) => ErrorResponse;
+    generatePromiseObjects: () => PromiseObject;
+    getCurrentPlatform: () => "unknown" | "macos" | "windows" | "linux";
+    getWebsocketUrl: (serverUrl: string) => string;
+    isSafari: () => boolean;
+    isValidURL: (url: string) => boolean;
+    isValidTransferSpec: (transferSpec: TransferSpec) => boolean;
+    randomUUID: () => string;
+    throwError: (message: string, debugData?: any) => Promise<any>;
+};
+export default _default;