@verdocs/web-sdk 1.1.0 → 1.2.0

package/dist/cjs/Auth-0ba9a04b.js

@@ -0,0 +1,68 @@
+'use strict';
+
+const Token = require('./Token-1ea6d834.js');
+
+/**
+ * Authenticate to Verdocs via user/password authentication
+ *
+ * ```typescript
+ * import {Auth} from '@verdocs/js-sdk/Auth';
+ * import {Transport} from '@verdocs/js-sdk/HTTP';
+ *
+ * const {accessToken} = await Auth.authenticateUser({ username: 'test@test.com', password: 'PASSWORD' });
+ * Transport.setAuthToken(accessToken);
+ * ```
+ */
+var authenticateUser = function (params) {
+    return Token.getEndpoint()
+        .api.post('/authentication/login', params)
+        .then(function (r) { return r.data; });
+};
+var clearSession = function (source, persist) {
+    Token.getEndpoint().setAuthorization(null);
+    if (persist) {
+        localStorage.removeItem(source);
+    }
+    return null;
+};
+/**
+ * Parses and sets the active session, optionally persisting (brower-only, persists to localStorage).
+ */
+var setSession = function (source, token, persist) {
+    if (persist === void 0) { persist = false; }
+    if (token === null) {
+        return clearSession(source, persist);
+    }
+    var session = Token.decodeAccessTokenBody(token || '');
+    if (session === null || (session.exp && session.exp * 1000 < new Date().getTime())) {
+        return clearSession(source, persist);
+    }
+    if (persist) {
+        localStorage.setItem(source, token);
+    }
+    Token.getEndpoint().setAuthorization(token);
+    return session;
+};
+/**
+ * Load a session from localStorage
+ */
+var loadSession = function (source) {
+    var token = localStorage.getItem(source);
+    if (!token) {
+        return null;
+    }
+    var session = Token.decodeAccessTokenBody(token);
+    if (!session) {
+        return null;
+    }
+    if (session.exp && session.exp * 1000 < new Date().getTime()) {
+        localStorage.removeItem(source);
+        return null;
+    }
+    Token.getEndpoint().setAuthorization(token);
+    return session;
+};
+
+exports.authenticateUser = authenticateUser;
+exports.loadSession = loadSession;
+exports.setSession = setSession;

package/dist/cjs/{Transport-68c8b1f4.js → Token-1ea6d834.js}

@@ -1805,9 +1805,14 @@ axios_1.default = _default;
 
 var axios = axios_1;
 
+var requestLogger = function (r) {
+    // tslint:disable-next-line
+    console.debug("[JS-SDK] ".concat(r.method.toUpperCase(), " ").concat(r.baseURL).concat(r.url), r.data ? JSON.stringify(r.data) : '');
+    return r;
+};
 /**
- * A VerdocsEndpoint is a specific connection and authorization session for calling the Verdocs APIs. Where the global
- * Transport is generally used to simpliy standard-user operations, Endpoints can be used for isolated session tasks.
+ * VerdocsEndpoint is a class wrapper for a specific connection and authorization context for calling the Verdocs APIs.
+ * Endpoints can be used for isolated session tasks.
  * For instance, ephemeral signing sessions may be created independently of a caller's status as an authenticated user.
  * In that case, an Endpoint can be created and authenticated, used for calls related to signing operations, then
  * discarded once signing is complete.
@@ -1823,31 +1828,19 @@ var axios = axios_1;
  *     .setClientID('1234)
  *     .setTimeout(5000);
  * ```
- *
- * @module
  */
-var requestLogger = function (r) {
-    // tslint:disable-next-line
-    console.debug("[JS-SDK] ".concat(r.method.toUpperCase(), " ").concat(r.baseURL).concat(r.url), r.data ? JSON.stringify(r.data) : '');
-    return r;
-};
 var VerdocsEndpoint = /** @class */ (function () {
     /**
-     * Create a new Endpoint to call Verdocs services.
+     * Create a new VerdocsEndpoint to call Verdocs platform services.
      *
      * ```typescript
      * import {VerdocsEndpoint} from '@verdocs/js-sdk/HTTP';
-     *
-     * console.log('Current timeout', Transport.getEndpoint().defaults.timeout);
+     * const endpoint = new VerdocsEndpoint();
      * ```
      */
-    function VerdocsEndpoint(_a) {
-        var _b = _a === void 0 ? {} : _a, baseURL = _b.baseURL, timeout = _b.timeout;
+    function VerdocsEndpoint() {
         this.requestLoggerId = null;
-        this.api = axios.create({
-            baseURL: baseURL || 'https://api.verdocs.com',
-            timeout: timeout || 6000,
-        });
+        this.api = axios.create({ baseURL: 'https://api.verdocs.com', timeout: 3000 });
     }
     /**
      * Set the timeout for API calls in milliseconds. 2000-4000ms is recommended for most purposes. 3000ms is the default.
@@ -1963,7 +1956,7 @@ var VerdocsEndpoint = /** @class */ (function () {
 // Also see globalThis for comments about why we're doing this in the first place.
 var ENDPOINT_KEY = Symbol.for('verdocs-api-endpoint');
 if (!globalThis_1[ENDPOINT_KEY]) {
-    globalThis_1[ENDPOINT_KEY] = new VerdocsEndpoint({ baseURL: 'https://api.verdocs.com/' });
+    globalThis_1[ENDPOINT_KEY] = new VerdocsEndpoint();
 }
 var globalEndpoint = globalThis_1[ENDPOINT_KEY];
 var activeEndpoint = globalEndpoint;
@@ -1998,6 +1991,75 @@ var setActiveEndpoint = function (e) {
     activeEndpoint = e || globalEndpoint;
 };
 
+/* tslint:disable:no-bitwise */
+var b64 = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=';
+// Regular expression to check formal correctness of base64 encoded strings
+var b64re = /^(?:[A-Za-z\d+\/]{4})*?(?:[A-Za-z\d+\/]{2}(?:==)?|[A-Za-z\d+\/]{3}=?)?$/;
+/**
+ * Simplified, Node/Browser-safe alternative to atob() for base64 decoding.
+ * Modified from https://github.com/MaxArt2501/base64-js/blob/master/base64.js
+ */
+var AtoB = function (str) {
+    // atob can work with strings with whitespaces, even inside the encoded part,
+    // but only \t, \n, \f, \r and ' ', which can be stripped.
+    str = String(str).replace(/[\t\n\f\r ]+/g, '');
+    if (!b64re.test(str))
+        throw new TypeError("Failed to execute 'atob' on 'Window': The string to be decoded is not correctly encoded.");
+    // Adding the padding if missing, for semplicity
+    str += '=='.slice(2 - (str.length & 3));
+    var bitmap;
+    var result = '';
+    var r1;
+    var r2;
+    var i = 0;
+    for (; i < str.length;) {
+        bitmap =
+            (b64.indexOf(str.charAt(i++)) << 18) |
+                (b64.indexOf(str.charAt(i++)) << 12) |
+                ((r1 = b64.indexOf(str.charAt(i++))) << 6) |
+                (r2 = b64.indexOf(str.charAt(i++)));
+        result +=
+            r1 === 64
+                ? String.fromCharCode((bitmap >> 16) & 255)
+                : r2 === 64
+                    ? String.fromCharCode((bitmap >> 16) & 255, (bitmap >> 8) & 255)
+                    : String.fromCharCode((bitmap >> 16) & 255, (bitmap >> 8) & 255, bitmap & 255);
+    }
+    return result;
+};
+/**
+ * Decode the body of a JWT. This helper may allow front-end applications to avoid a dependency on `jsonwebtoken` in
+ * many cases. Note that this should only be used for true JWTs. Opaque tokens will cause this to throw.
+ */
+var decodeTokenBody = function (token) { return JSON.parse(AtoB((token || '').split('.')[1] || '')); };
+/**
+ * Decode the body of an Verdocs access token. Note that raw tokens contain namespaced fields, e.g.
+ * `https://verdocs.com/profile_id`. To make these tokens easier to use in front-end code, this name-spacing
+ * will be removed. Note that user and signing sessions have different access token formats. The calling
+ * application should distinguish between the two based on the context of the authenticated session, or by
+ * the presence of the `document_id` field, which will only be present for signing sessions.
+ */
+var decodeAccessTokenBody = function (token) {
+    var decoded;
+    try {
+        decoded = decodeTokenBody(token);
+        if (decoded === null) {
+            return null;
+        }
+    }
+    catch (e) {
+        return null;
+    }
+    Object.keys(decoded).forEach(function (key) {
+        if (typeof key === 'string' && key.startsWith('https://verdocs.com/')) {
+            decoded[key.replace('https://verdocs.com/', '')] = decoded[key];
+            delete decoded[key];
+        }
+    });
+    return decoded;
+};
+
 exports.VerdocsEndpoint = VerdocsEndpoint;
+exports.decodeAccessTokenBody = decodeAccessTokenBody;
 exports.getEndpoint = getEndpoint;
 exports.setActiveEndpoint = setActiveEndpoint;