hevy-shared 1.0.962 → 1.0.964

package/README.md

@@ -1,5 +1,20 @@
 # hevy-shared
 Common code shared by the other repos.
 
-## Deploying
-Merging PRs to `master` will automatically trigger the deployment of a new patch version to npm using github actions (see ./github/workflows). Go to https://www.npmjs.com/package/hevy-shared for more information
+## Publishing to npm
+
+There are two ways of publishing a new version of `hevy-shared` to npm.
+
+### Automatically
+
+Merging PRs to `master` will automatically trigger the publishing of a new patch version to npm using Github Actions (see .github/workflows). Go to https://www.npmjs.com/package/hevy-shared for more information.
+
+**Important note:** Please do **NOT** merge your `hevy-shared` PRs into `master` until _all_ the other repos (regardless of whether they use npm or Git submodules) which depend on your `hevy-shared` PR have their respective PRs merged into their respective main branches.
+Doing so should help avoid type errors and conflicts more than doing it the other way around, even though they can still happen.
+
+### Manually
+
+To publish manually, run `npm run ci-build` _on the branch of your choice_. This is useful if you need to get your changes into a repo which doesn't use Git submodules.
+
+Running the command will print the next unused version number, which should be the version of the newly published package. You will just have to wait until it's actually published before you can install it.
+You can run `npm view hevy-shared version` to check the current `latest` version that's available on npm at any given moment.

package/built/API/APIClient.d.ts

@@ -0,0 +1,157 @@
+import { ClientAuthToken, DeepReadonly } from '..';
+import { RequestConfig, HTTPResponse, HTTPClient, HTTPRequestCompletionCallback, HTTPErrorHandler } from './types';
+interface HevyAPIClientConfig<UserContext> {
+    /**
+     * How long before predicted token expiry to request a new token. We request
+     * new tokens a little bit before they expire, so that we don't have to wait
+     * for the backend to send us a 401 first. We do it pre-emptively so that we
+     * wouldn't need to wait for requests to fail first, and then retry them.
+     *
+     * Optional.
+     *
+     * @default {1 minute}
+     */
+    readonly tokenExpirySafetyThresholdMs?: number;
+    /**
+     * How long we expect the access token to be valid for. Used to override the
+     * expiry time sent by the backend in case the client clock is in the future
+     * and the client thinks that the token will expire sooner than it actually
+     * will. Even if this assumption ever stops being correct, the client will be
+     * able to self-correct by receiving an `AccessTokenExpired` 401 response.
+     *
+     * Optional.
+     *
+     * @default {15 minutes}
+     */
+    readonly accessTokenMinimumValidAgeMs?: number;
+    /**
+     * Minimum time between successive calls to the `auth/refresh_token` endpoint
+     * in case it doesn't return an error. Also used to deal with potential clock
+     * issues on the client side, or some unforeseen issue on the backend, as the
+     * last line of defence. No matter what may happen, we absolutely never ever
+     * want to end up accidentally spamming this endpoint because it could have a
+     * cascading clusterfuck effect on all the other requests.
+     *
+     * Optional.
+     *
+     * @default {20 seconds}
+     */
+    readonly tokenRefreshThrottleMs?: number;
+    /**
+     * The API endpoint used to refresh the auth tokens using a refresh token.
+     * The URL is relative to the backend base URL.
+     *
+     * Optional.
+     *
+     * @default {POST /auth/refresh_token}
+     */
+    readonly refreshAuthTokenApiEndpoint?: {
+        readonly method: 'post';
+        readonly url: string;
+    };
+    /**
+     * Callback to use when receiving a new auth token. Used to send it to the
+     * consumer of the class to save the new token to its local storage.
+     *
+     * Required.
+     */
+    onNewAuthToken(newAuthToken: ClientAuthToken, userContext: UserContext): void;
+    /**
+     * Defines an arbitrary object to be passed back to the `onNewAuthToken`. The
+     * value is computed at the time when the request is made. Useful for passing
+     * back state that may have gotten changed during the time while the request
+     * was being processed, such as holding onto a userId across a logout action.
+     *
+     * Optional.
+     */
+    getUserContext?(): UserContext;
+    /**
+     * Callback to use when receiving an HTTP error response from the backend, to
+     * determine whether it is a response indicating that the token has expired.
+     *
+     * Optional.
+     *
+     * @default ...
+     */
+    isAccessTokenExpiredResponse?(response: HTTPResponse<unknown>): boolean;
+    /**
+     * Callback to use when receiving an HTTP error response from the backend, to
+     * determine whether it is a response indicating that the token is invalid.
+     *
+     * Optional.
+     *
+     * @default ...
+     */
+    isAccessTokenInvalidResponse?(response: HTTPResponse<unknown>): boolean;
+}
+export declare class HevyAPIClient<UserContext = never> {
+    private static readonly DEFAULT_TOKEN_EXPIRY_SAFETY_THRESHOLD_MS;
+    private static readonly DEFAULT_ACCESS_TOKEN_MINIMUM_VALID_AGE_MS;
+    private static readonly DEFAULT_TOKEN_REFRESH_THROTTLE_MS;
+    private static readonly DEFAULT_REFRESH_AUTH_TOKEN_API_ENDPOINT;
+    private readonly _config;
+    private _requestCompletionCallbacks;
+    private _errorHandlers;
+    private _authTokenFactory;
+    private _legacyAuthToken;
+    private _httpClient;
+    private _lastTokenRefresh;
+    private _lastSessionDelete;
+    constructor(httpClient: HTTPClient, config: HevyAPIClientConfig<UserContext>);
+    private get _authToken();
+    private get _authHeaders();
+    private _addHeaders;
+    private refreshExpiredAuthToken;
+    private forceRefreshAuthToken;
+    private waitForTokenRefresh;
+    private get _isTokenRecentlyRefreshed();
+    private _refreshAuthToken;
+    private _handleResponse;
+    isAccessTokenExpiredResponse(response: HTTPResponse<unknown>): boolean;
+    isAccessTokenInvalidResponse(response: HTTPResponse<unknown>): boolean;
+    get refreshAuthTokenApiEndpoint(): {
+        readonly method: "post";
+        readonly url: string;
+    };
+    setAuthToken(newAuthToken: {
+        authToken: DeepReadonly<ClientAuthToken> | null;
+        legacyAuthToken: string | null;
+    }): Promise<void>;
+    setAuthToken(newAuthToken: {
+        getAuthToken: () => ClientAuthToken | null;
+        legacyAuthToken: string | null;
+    }): Promise<void>;
+    clearAuthToken(): Promise<void>;
+    get isAuthenticated(): boolean;
+    markSessionDeleted(): void;
+    /**
+     * Adds a callback to be executed whenever a request has finished processing.
+     * This means either that the request has received a response, or that there
+     * was an error. In the case of an error, it may be either an HTTP error from
+     * the server, or some other type of error, such as a network error.
+     *
+     * This is a lower level API than {@link attachErrorHandler} - prefer using
+     * that one instead of this one if it's enough to suit your needs.
+     */
+    attachRequestCompletionCallback(onResult: HTTPRequestCompletionCallback): void;
+    removeRequestCompletionCallbacks(): void;
+    /**
+     * Adds a callback to be executed on receiving an HTTP error from the server.
+     * This callback will not be executed for any other type of error, such as a
+     * network error. For that and more, use {@link attachRequestCompletionCallback}.
+     */
+    attachErrorHandler(onError: HTTPErrorHandler<{
+        willRetry: boolean;
+        isTokenRefreshedAfterRequest: boolean;
+        isPreviousSession: boolean;
+    }>): void;
+    removeErrorHandlers(): void;
+    get<T = never>(url: string, config?: RequestConfig): Promise<HTTPResponse<T>>;
+    delete<T = never>(url: string, config?: RequestConfig): Promise<HTTPResponse<T>>;
+    head<T = never>(url: string, config?: RequestConfig): Promise<HTTPResponse<T>>;
+    options<T = never>(url: string, config?: RequestConfig): Promise<HTTPResponse<T>>;
+    post<T = never, R = unknown>(url: string, data?: R, config?: RequestConfig): Promise<HTTPResponse<T>>;
+    put<T = never, R = unknown>(url: string, data?: R, config?: RequestConfig): Promise<HTTPResponse<T>>;
+    patch<T = never, R = unknown>(url: string, data?: R, config?: RequestConfig): Promise<HTTPResponse<T>>;
+}
+export {};

package/built/API/APIClient.js

@@ -0,0 +1,381 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+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());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HevyAPIClient = void 0;
+const __1 = require("..");
+const types_1 = require("./types");
+class HevyAPIClient {
+    constructor(httpClient, config) {
+        this._requestCompletionCallbacks = [];
+        this._errorHandlers = [];
+        this._authTokenFactory = {
+            type: 'value',
+            value: null,
+        };
+        this._legacyAuthToken = null;
+        this._addHeaders = (headers, config) => (Object.assign(Object.assign({}, config), { headers: Object.assign(Object.assign({}, config === null || config === void 0 ? void 0 : config.headers), headers) }));
+        this._httpClient = httpClient;
+        this._config = Object.assign({ tokenExpirySafetyThresholdMs: HevyAPIClient.DEFAULT_TOKEN_EXPIRY_SAFETY_THRESHOLD_MS, accessTokenMinimumValidAgeMs: HevyAPIClient.DEFAULT_ACCESS_TOKEN_MINIMUM_VALID_AGE_MS, tokenRefreshThrottleMs: HevyAPIClient.DEFAULT_TOKEN_REFRESH_THROTTLE_MS, refreshAuthTokenApiEndpoint: HevyAPIClient.DEFAULT_REFRESH_AUTH_TOKEN_API_ENDPOINT, isAccessTokenExpiredResponse: (response) => response.status === 401 &&
+                (0, types_1.isHTTPErrorResponse)(response) &&
+                response.data.error === 'AccessTokenExpired', isAccessTokenInvalidResponse: (response) => response.status === 401 &&
+                (0, types_1.isHTTPErrorResponse)(response) &&
+                response.data.error === 'InvalidAccessToken', getUserContext: () => undefined }, config);
+        const classProperties = Object.getOwnPropertyNames(Object.getPrototypeOf(this)).filter((m) => m in this && typeof m === 'string' && m !== 'constructor');
+        classProperties.forEach((m) => {
+            if (typeof this[m] === 'function')
+                this[m] = this[m].bind(this);
+        });
+    }
+    get _authToken() {
+        switch (this._authTokenFactory.type) {
+            case 'value':
+                return this._authTokenFactory.value;
+            case 'getter':
+                return this._authTokenFactory.get();
+        }
+    }
+    get _authHeaders() {
+        return Object.assign(Object.assign(Object.assign({}, (this._authToken
+            ? { authorization: `Bearer ${this._authToken.access_token}` }
+            : {})), (this._legacyAuthToken ? { 'auth-token': this._legacyAuthToken } : {})), { 'x-client-time': String(new Date().valueOf() / 1000) });
+    }
+    refreshExpiredAuthToken(userContext) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { _authToken } = this;
+            if (!_authToken)
+                return;
+            if (new Date().valueOf() <=
+                new Date(_authToken.expires_at).valueOf() -
+                    this._config.tokenExpirySafetyThresholdMs) {
+                // Token is still valid, at least according to the client. Don't refresh.
+                return;
+            }
+            yield this._refreshAuthToken(_authToken, userContext);
+        });
+    }
+    forceRefreshAuthToken(userContext) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { _authToken } = this;
+            if (!_authToken)
+                return;
+            yield this._refreshAuthToken(_authToken, userContext);
+        });
+    }
+    waitForTokenRefresh() {
+        return __awaiter(this, void 0, void 0, function* () {
+            // This may look like it does nothing, but that is absolutely not the case.
+            // Do not remove this function!
+        });
+    }
+    get _isTokenRecentlyRefreshed() {
+        const { _lastTokenRefresh } = this;
+        return (_lastTokenRefresh !== undefined &&
+            _lastTokenRefresh.valueOf() >
+                new Date().valueOf() - this._config.tokenRefreshThrottleMs);
+    }
+    _refreshAuthToken(authToken, userContext) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this._isTokenRecentlyRefreshed) {
+                // We have called this function recently. Do not ever spam this endpoint.
+                // Also, if any request needs to be retried due to issues with the client
+                // clock being out of sync with the backend, do that with the last token
+                // that was obtained after a 401 with the `AccessTokenExpired` response.
+                return;
+            }
+            this._lastTokenRefresh = new Date();
+            const { access_token, refresh_token } = authToken;
+            const { method, url } = this.refreshAuthTokenApiEndpoint;
+            const headers = {
+                authorization: `Bearer ${access_token}`,
+                'x-client-time': String(new Date().valueOf() / 1000),
+            };
+            // This will throw and bail out if the request fails.
+            const response = yield this._handleResponse({
+                method,
+                url,
+                headers,
+                try: () => this._httpClient[method](url, { refresh_token }, { headers }),
+            }, userContext, false);
+            const newToken = {
+                access_token: response.data.access_token,
+                refresh_token: response.data.refresh_token,
+                expires_at: new Date(response.data.expires_at),
+            };
+            /**
+             * Do not attempt to auto-refresh the token before this time - by default,
+             * {@link HevyAPIClient.DEFAULT_ACCESS_TOKEN_MINIMUM_VALID_AGE_MS 15 mins}
+             * after the current time. Normally the backend will generate a token that
+             * lives for at least 15 minutes, but since it sends the expiry timestamp
+             * rather than a max age in relative time units, even if the client's clock
+             * is severely out of sync, we don't want to think that the token has
+             * expired when in reality it hasn't.
+             *
+             * If we ever change the access tokens to really live for less than 15 min,
+             * this assertion will no longer hold, and any tokens that are expired
+             * despite the client not realising it will be handled by the logic that
+             * handles 401s with the `AccessTokenExpired` error response.
+             */
+            const earliestAutoRefreshUnixMs = new Date().valueOf() + this._config.accessTokenMinimumValidAgeMs;
+            if (newToken.expires_at.valueOf() < earliestAutoRefreshUnixMs) {
+                newToken.expires_at = new Date(earliestAutoRefreshUnixMs);
+            }
+            if (this._authTokenFactory.type === 'value') {
+                this._authTokenFactory.value = newToken;
+            }
+            this._config.onNewAuthToken(newToken, userContext);
+        });
+    }
+    _handleResponse(request_1, userContext_1) {
+        return __awaiter(this, arguments, void 0, function* (request, userContext, retryOnFailure = !this._isTokenRecentlyRefreshed) {
+            const requestTime = new Date();
+            try {
+                const response = yield request.try();
+                if (response.status >= 400) {
+                    throw Object.assign(new Error(`Request failed with status code ${response.status}`), {
+                        response,
+                    });
+                }
+                this._requestCompletionCallbacks.forEach((cb) => cb({ isSuccess: true, value: response }, request));
+                return response;
+            }
+            catch (e) {
+                this._requestCompletionCallbacks.forEach((cb) => cb({ isSuccess: false, error: e }, request));
+                if (!(0, types_1.isHTTPError)(e))
+                    throw e;
+                const { response } = e;
+                /**
+                 * We've had a {@link _refreshAuthToken} called _after_ this request was
+                 * made. If that request reached the server before this one did, this one
+                 * will have failed with a 401 because it's using the old token.
+                 *
+                 * In this (relatively unlikely) scenario, we will want to retry the
+                 * request, and also we will not want to log the user out.
+                 */
+                const isTokenRefreshedAfterRequest = this._lastTokenRefresh !== undefined &&
+                    requestTime < this._lastTokenRefresh;
+                /**
+                 * Similar to the above, but this will be `true` if the user has logged
+                 * out after the request was made, i.e. the session that the request was
+                 * made within is is (probably) no longer valid. In this case, we don't
+                 * want to retry the request, but we also don't want to log the user out,
+                 * in case that they've logged in to another session in the meantime.
+                 */
+                const isPreviousSession = this._lastSessionDelete !== undefined &&
+                    requestTime < this._lastSessionDelete;
+                this._errorHandlers.forEach((cb) => cb(response, request, {
+                    willRetry: retryOnFailure,
+                    isTokenRefreshedAfterRequest,
+                    isPreviousSession,
+                }));
+                if (retryOnFailure && this.isAccessTokenExpiredResponse(response)) {
+                    yield this.forceRefreshAuthToken(userContext);
+                    return yield this._handleResponse(request, userContext, false);
+                }
+                else if (retryOnFailure &&
+                    this.isAccessTokenInvalidResponse(response) &&
+                    isTokenRefreshedAfterRequest &&
+                    !isPreviousSession) {
+                    yield this.waitForTokenRefresh();
+                    return yield this._handleResponse(request, userContext, false);
+                }
+                else {
+                    throw e;
+                }
+            }
+        });
+    }
+    isAccessTokenExpiredResponse(response) {
+        return this._config.isAccessTokenExpiredResponse(response);
+    }
+    isAccessTokenInvalidResponse(response) {
+        return this._config.isAccessTokenInvalidResponse(response);
+    }
+    get refreshAuthTokenApiEndpoint() {
+        return Object.assign({}, this._config.refreshAuthTokenApiEndpoint);
+    }
+    setAuthToken(newAuthToken) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.waitForTokenRefresh();
+            const { authToken, getAuthToken, legacyAuthToken } = newAuthToken;
+            if (getAuthToken !== undefined && authToken === undefined) {
+                this._authTokenFactory = { type: 'getter', get: getAuthToken };
+            }
+            else if (authToken !== undefined && getAuthToken === undefined) {
+                this._authTokenFactory = { type: 'value', value: authToken };
+            }
+            else {
+                throw new Error("Invalid arguments: exactly one of `authToken' or `getAuthToken' is required");
+            }
+            this._legacyAuthToken = legacyAuthToken;
+            this._lastTokenRefresh = undefined;
+        });
+    }
+    clearAuthToken() {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.waitForTokenRefresh();
+            this._authTokenFactory = { type: 'value', value: null };
+            this._legacyAuthToken = null;
+            this._lastTokenRefresh = undefined;
+        });
+    }
+    get isAuthenticated() {
+        if (this._authTokenFactory.type === 'value' &&
+            this._authTokenFactory.value === null) {
+            return false;
+        }
+        else {
+            return true;
+        }
+    }
+    markSessionDeleted() {
+        this._lastSessionDelete = new Date();
+    }
+    /**
+     * Adds a callback to be executed whenever a request has finished processing.
+     * This means either that the request has received a response, or that there
+     * was an error. In the case of an error, it may be either an HTTP error from
+     * the server, or some other type of error, such as a network error.
+     *
+     * This is a lower level API than {@link attachErrorHandler} - prefer using
+     * that one instead of this one if it's enough to suit your needs.
+     */
+    attachRequestCompletionCallback(onResult) {
+        this._requestCompletionCallbacks.push(onResult);
+    }
+    removeRequestCompletionCallbacks() {
+        this._requestCompletionCallbacks.length = 0;
+    }
+    /**
+     * Adds a callback to be executed on receiving an HTTP error from the server.
+     * This callback will not be executed for any other type of error, such as a
+     * network error. For that and more, use {@link attachRequestCompletionCallback}.
+     */
+    attachErrorHandler(onError) {
+        this._errorHandlers.push(onError);
+    }
+    removeErrorHandlers() {
+        this._errorHandlers.length = 0;
+    }
+    get(url, config) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const userContext = this._config.getUserContext();
+            yield this.refreshExpiredAuthToken(userContext);
+            const method = 'get';
+            return this._handleResponse({
+                method,
+                url,
+                headers: this._authHeaders,
+                try: () => this._httpClient[method](url, this._addHeaders(this._authHeaders, config)),
+            }, userContext);
+        });
+    }
+    delete(url, config) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const userContext = this._config.getUserContext();
+            yield this.refreshExpiredAuthToken(userContext);
+            const method = 'delete';
+            return this._handleResponse({
+                method,
+                url,
+                headers: this._authHeaders,
+                try: () => this._httpClient[method](url, this._addHeaders(this._authHeaders, config)),
+            }, userContext);
+        });
+    }
+    head(url, config) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const userContext = this._config.getUserContext();
+            yield this.refreshExpiredAuthToken(userContext);
+            const method = 'head';
+            return this._handleResponse({
+                method,
+                url,
+                headers: this._authHeaders,
+                try: () => this._httpClient[method](url, this._addHeaders(this._authHeaders, config)),
+            }, userContext);
+        });
+    }
+    options(url, config) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const userContext = this._config.getUserContext();
+            yield this.refreshExpiredAuthToken(userContext);
+            const method = 'options';
+            return this._handleResponse({
+                method,
+                url,
+                headers: this._authHeaders,
+                try: () => this._httpClient[method](url, this._addHeaders(this._authHeaders, config)),
+            }, userContext);
+        });
+    }
+    post(url, data, config) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const userContext = this._config.getUserContext();
+            yield this.refreshExpiredAuthToken(userContext);
+            const method = 'post';
+            return this._handleResponse({
+                method,
+                url,
+                headers: this._authHeaders,
+                try: () => this._httpClient[method](url, data, this._addHeaders(this._authHeaders, config)),
+            }, userContext);
+        });
+    }
+    put(url, data, config) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const userContext = this._config.getUserContext();
+            yield this.refreshExpiredAuthToken(userContext);
+            const method = 'put';
+            return this._handleResponse({
+                method,
+                url,
+                headers: this._authHeaders,
+                try: () => this._httpClient[method](url, data, this._addHeaders(this._authHeaders, config)),
+            }, userContext);
+        });
+    }
+    patch(url, data, config) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const userContext = this._config.getUserContext();
+            yield this.refreshExpiredAuthToken(userContext);
+            const method = 'patch';
+            return this._handleResponse({
+                method,
+                url,
+                headers: this._authHeaders,
+                try: () => this._httpClient[method](url, data, this._addHeaders(this._authHeaders, config)),
+            }, userContext);
+        });
+    }
+}
+exports.HevyAPIClient = HevyAPIClient;
+HevyAPIClient.DEFAULT_TOKEN_EXPIRY_SAFETY_THRESHOLD_MS = 60000;
+HevyAPIClient.DEFAULT_ACCESS_TOKEN_MINIMUM_VALID_AGE_MS = 900000;
+HevyAPIClient.DEFAULT_TOKEN_REFRESH_THROTTLE_MS = 20000;
+HevyAPIClient.DEFAULT_REFRESH_AUTH_TOKEN_API_ENDPOINT = {
+    method: 'post',
+    url: 'auth/refresh_token',
+};
+__decorate([
+    (0, __1.synchronized)(true, 'refreshAuthToken')
+], HevyAPIClient.prototype, "refreshExpiredAuthToken", null);
+__decorate([
+    (0, __1.synchronized)(true, 'refreshAuthToken')
+], HevyAPIClient.prototype, "forceRefreshAuthToken", null);
+__decorate([
+    (0, __1.synchronized)(true, 'refreshAuthToken')
+], HevyAPIClient.prototype, "waitForTokenRefresh", null);

package/built/API/index.d.ts

@@ -0,0 +1,2 @@
+export * from './APIClient';
+export * from './types';

package/built/API/index.js

@@ -0,0 +1,18 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./APIClient"), exports);
+__exportStar(require("./types"), exports);

package/built/API/types.d.ts

@@ -0,0 +1,38 @@
+import { Result } from '..';
+export interface HTTPClient {
+    get<T>(url: string, config?: RequestConfig): Promise<HTTPResponse<T>>;
+    delete<T>(url: string, config?: RequestConfig): Promise<HTTPResponse<T>>;
+    head<T>(url: string, config?: RequestConfig): Promise<HTTPResponse<T>>;
+    options<T>(url: string, config?: RequestConfig): Promise<HTTPResponse<T>>;
+    post<T, R = unknown>(url: string, data?: R, config?: RequestConfig): Promise<HTTPResponse<T>>;
+    put<T, R = unknown>(url: string, data?: R, config?: RequestConfig): Promise<HTTPResponse<T>>;
+    patch<T, R = unknown>(url: string, data?: R, config?: RequestConfig): Promise<HTTPResponse<T>>;
+}
+export interface RequestConfig {
+    headers?: Record<string, string>;
+    baseURL?: string;
+    params?: unknown;
+    signal?: AbortSignal;
+}
+export type HTTPMethod = keyof {
+    [K in keyof HTTPClient as HTTPClient[K] extends (...args: any) => Promise<HTTPResponse<never>> ? K : never]: never;
+};
+export interface HTTPRequestFactory<T = unknown> {
+    method: HTTPMethod;
+    url: string;
+    headers: Record<string, string>;
+    try(): Promise<HTTPResponse<T>>;
+}
+export type HTTPRequestCompletionCallback<T = unknown, R = unknown> = (result: Result<HTTPResponse<T>>, request: HTTPRequestFactory<R>) => void;
+export type HTTPErrorHandler<E, T = unknown, R = unknown> = (response: HTTPResponse<T>, request: HTTPRequestFactory<R>, extraData: E) => void;
+export interface HTTPResponse<T = unknown> {
+    status: number;
+    data: T;
+}
+export interface HTTPError<T = unknown> extends Error {
+    response: HTTPResponse<T>;
+}
+export declare const isHTTPError: <T = unknown>(e: unknown) => e is HTTPError<T>;
+export declare const isHTTPErrorResponse: (response: HTTPResponse<unknown>) => response is HTTPResponse<{
+    error: string;
+}>;

package/built/API/types.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isHTTPErrorResponse = exports.isHTTPError = void 0;
+const isHTTPError = (e) => {
+    return (e instanceof Error &&
+        'response' in e &&
+        typeof e.response === 'object' &&
+        e.response !== null &&
+        'status' in e.response &&
+        typeof e.response.status === 'number');
+};
+exports.isHTTPError = isHTTPError;
+const isHTTPErrorResponse = (response) => response.status >= 400 &&
+    typeof response.data === 'object' &&
+    response.data !== null &&
+    'error' in response.data &&
+    typeof response.data.error === 'string';
+exports.isHTTPErrorResponse = isHTTPErrorResponse;

package/built/adjustEventTokens.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Manage adjust events at https://suite.adjust.com/apps/na3q7q6avq4g/events
+ */
+export declare const ADJUST_EVENT_TOKENS: {
+    logWorkout: string;
+    purchase: string;
+    signupComplete: string;
+    renewal: string;
+    updateSexMale: string;
+    updateSexFemale: string;
+    updateSexOther: string;
+    updateAge18Through28: string;
+    updateAge29Through44: string;
+    updateAge45AndUp: string;
+};
+export type AdjustEventToken = typeof ADJUST_EVENT_TOKENS[keyof typeof ADJUST_EVENT_TOKENS];