@bytescale/sdk 3.0.0-alpha.9 → 3.2.0

package/dist/types/index.d.ts

@@ -1,2 +1,2 @@
 export * from "./public/shared";
-export * from "./public/node";
+export * from "./public/browser";

package/dist/types/private/AuthSessionState.d.ts

@@ -1,13 +1,30 @@
 import { AuthSession } from "./model/AuthSession";
+import { Mutex } from "./Mutex";
+/**
+ * Maintains a global session state, even across package versions.
+ *
+ * This is to allow users to start auth sessions via the Bytescale JavaScript SDK, where due to versioning or other
+ * bundling issues, the Bytescale Upload Widget has been bundled with a different Bytescale JavaScript SDK. In this
+ * scenario, the user wouldn't be able to start an auth session with the Bytescale Upload Widget. Therefore, we use
+ * global state (i.e. on the window) to ensure the session state can be shared between the user's instance of the
+ * Bytescale JavaScript SDK and the Upload Widget's version of the Bytescale JavaScript SDK.
+ *
+ * Users also frequently have problems caused by them not keeping track of *Api and *Manager instances correctly, so
+ * making this global prevents a lot of common mistakes.
+ */
 export declare class AuthSessionState {
+    private static readonly stateKey;
+    private static readonly mutexKey;
     /**
-     * Intentionally global:
-     *
-     * Users frequently have problems caused by them not keeping track of *Api and *Manager instances correctly, so we
-     * make this global as in 99.9% of cases, this is what users want, and it prevents lots of common mistakes.
-     *
-     * We only set this in the browser.
-     * Never in Node.js.
+     * Called in the browser only.
      */
-    static session: AuthSession | undefined;
+    static getMutex(): Mutex;
+    /**
+     * Called in the browser only.
+     */
+    static setSession(session: AuthSession | undefined): void;
+    /**
+     * Called in the browser and in Node.js (so we check the env before calling env-specific code).
+     */
+    static getSession(): AuthSession | undefined;
 }

package/dist/types/private/EnvChecker.d.ts

@@ -1,4 +1,4 @@
 export declare class EnvChecker {
-    static isNodeJs(): boolean;
+    static isBrowser(): boolean;
     static methodRequiresBrowser(methodName: string): Error;
 }

package/dist/types/private/Mutex.d.ts

@@ -1,5 +1,5 @@
 /**
- * A lightweight mutex. (Other libraries contain too many features and we want to keep the size upload-js down).
+ * A lightweight mutex. (Other libraries contain too many features and we want to keep size down).
  *
  * Characteristics:
  * - Non-reentrant.

package/dist/types/private/StreamUtils.d.ts

@@ -3,6 +3,7 @@ import type * as stream from "stream";
 export declare class StreamUtils {
     static create(): stream.Readable;
     static empty(): NodeJS.ReadableStream;
+    static fromArrayBuffer(buffer: ArrayBuffer): NodeJS.ReadableStream;
     static fromBuffer(buffer: Buffer): NodeJS.ReadableStream;
     static endStream(readable: stream.Readable): void;
 }

package/dist/types/private/UploadManagerBase.d.ts

@@ -11,6 +11,7 @@ import { UploadManagerParams, UploadSource } from "../public/shared/CommonTypes"
 export declare abstract class UploadManagerBase<TSource, TInit> implements UploadManagerInterface {
     protected readonly config: BytescaleApiClientConfig;
     protected readonly stringMimeType = "text/plain";
+    private readonly accountId;
     private readonly defaultMaxConcurrentUploadParts;
     private readonly intervalMs;
     private readonly uploadApi;
@@ -28,7 +29,11 @@ export declare abstract class UploadManagerBase<TSource, TInit> implements Uploa
     protected abstract doPutUploadPart(part: UploadPart, contentLength: number, source: TSource, onProgress: (bytesSentDelta: number) => void, addCancellationHandler: AddCancellationHandler): Promise<PutUploadPartResult>;
     private onIntervalTick;
     private makeCancellationMethods;
-    private makeProgressCallback;
+    /**
+     * Returns a callback, which when called, returns a callback that can be used by ONE specific part to report its progress.
+     */
+    private makeOnProgressForPartFactory;
+    private makeProgressEvent;
     private assertNotCancelled;
     private isCancelled;
     private beginUpload;

package/dist/types/private/UploadManagerBrowserWorkerBase.d.ts

@@ -0,0 +1,19 @@
+import { UploadManagerBase } from "./UploadManagerBase";
+import { UploadSourceProcessedBrowser, UploadSourceProcessedWorker } from "./model/UploadSourceProcessed";
+import { PreUploadInfo } from "./model/PreUploadInfo";
+import { UploadPart } from "../public/shared/generated";
+import { UploadManagerParams, UploadSource } from "../public/shared/CommonTypes";
+declare type BrowserOrWorkerUploadSource = UploadSourceProcessedBrowser | UploadSourceProcessedWorker;
+/**
+ * The "browser" and "worker" runtimes support the same input types, but the former uses XHR and the latter uses Fetch.
+ */
+export declare abstract class UploadManagerBrowserWorkerBase extends UploadManagerBase<BrowserOrWorkerUploadSource, undefined> {
+    protected processUploadSource(data: UploadSource): BrowserOrWorkerUploadSource;
+    protected getPreUploadInfoPartial(_request: UploadManagerParams, data: BrowserOrWorkerUploadSource): Partial<PreUploadInfo> & {
+        size: number;
+    };
+    protected preUpload(_source: BrowserOrWorkerUploadSource): undefined;
+    protected postUpload(_init: undefined): Promise<void>;
+    protected getRequestBody(part: UploadPart, blob: BrowserOrWorkerUploadSource): Blob | ArrayBuffer;
+}
+export {};

package/dist/types/private/UploadManagerFetchUtils.d.ts

@@ -0,0 +1,8 @@
+import { BytescaleApiClientConfig, UploadPart } from "../public/shared";
+import { AddCancellationHandler } from "./model/AddCancellationHandler";
+export declare class UploadManagerFetchUtils {
+    static doPutUploadPart(config: BytescaleApiClientConfig, part: UploadPart, content: BodyInit, contentLength: number, addCancellationHandler: AddCancellationHandler): Promise<{
+        etag: string | undefined;
+        status: number;
+    }>;
+}

package/dist/types/private/model/AuthManagerInterface.d.ts

@@ -1,3 +1,24 @@
+import { BytescaleApiClientConfig } from "../../public/shared";
+export interface BeginAuthSessionParams {
+    /**
+     * The account ID to authorize requests for.
+     */
+    accountId: string;
+    /**
+     * Headers to send to your backend API.
+     *
+     * IMPORTANT: do not call 'AuthManager.beginAuthSession' or 'AuthManager.endAuthSession' inside this callback, as this will cause a deadlock.
+     */
+    authHeaders: () => Promise<Record<string, string>>;
+    /**
+     * The fully-qualified URL for your backend API's auth endpoint.
+     */
+    authUrl: string;
+    /**
+     * Optional configuration.
+     */
+    options?: Pick<BytescaleApiClientConfig, "fetchApi" | "cdnUrl">;
+}
 export interface AuthManagerInterface {
     /**
      * Begins an authenticated Bytescale API and Bytescale CDN session.
@@ -21,12 +42,8 @@ export interface AuthManagerInterface {
      * 2) The JWT will be saved to a cookie scoped to the Bytescale CDN. This allows the user to view private files via the URL in the browser, including <img> elements on the page that reference private images, etc.
      *
      * 3) The JWT will also be added as a request header via 'authorization-token' to all Bytescale API requests made via this SDK. This allows the user to upload private files and perform administrative operations permitted by the JWT, such as deleting files, etc.
-     *
-     * @param authUrl The fully-qualified URL for your backend API's auth endpoint.
-     * @param authHeaders Headers to send to your backend API.
-     *                    IMPORTANT: do not call '*AuthSession' inside this callback, as this will cause a deadlock.
      */
-    beginAuthSession: (authUrl: string, authHeaders: () => Promise<Record<string, string>>) => Promise<void>;
+    beginAuthSession: (params: BeginAuthSessionParams) => Promise<void>;
     /**
      * Ends an authenticated Bytescale API and Bytescale CDN session.
      *

package/dist/types/private/model/AuthSession.d.ts

@@ -1,7 +1,7 @@
+import { BeginAuthSessionParams } from "./AuthManagerInterface";
 export interface AuthSession {
     accessToken: string | undefined;
     accessTokenRefreshHandle: number | undefined;
-    authHeaders: () => Promise<Record<string, string>>;
-    authUrl: string;
     isActive: boolean;
+    params: BeginAuthSessionParams;
 }

package/dist/types/private/model/OnPartProgress.d.ts

@@ -1 +1 @@
-export declare type OnPartProgress = (bytesSentDelta: number) => void;
+export declare type OnPartProgress = (bytesSentTotalForPart: number) => void;

package/dist/types/private/model/UploadSourceProcessed.d.ts

@@ -9,10 +9,15 @@ export interface UploadSourceBuffer {
     type: "Buffer";
     value: Buffer;
 }
+export interface UploadSourceArrayBuffer {
+    type: "ArrayBuffer";
+    value: ArrayBuffer;
+}
 export interface UploadSourceStream {
     type: "Stream";
     value: NodeChunkedStream;
 }
-export declare type UploadSourceProcessedIsomorphic = UploadSourceBlob;
+export declare type UploadSourceProcessedIsomorphic = UploadSourceBlob | UploadSourceArrayBuffer;
 export declare type UploadSourceProcessedBrowser = UploadSourceProcessedIsomorphic;
+export declare type UploadSourceProcessedWorker = UploadSourceProcessedIsomorphic;
 export declare type UploadSourceProcessedNode = UploadSourceStream | UploadSourceBuffer | UploadSourceProcessedIsomorphic;

package/dist/types/public/browser/AuthManagerBrowser.d.ts

@@ -1,7 +1,5 @@
-import { AuthManagerInterface } from "../../private/model/AuthManagerInterface";
-import { BaseAPI, BytescaleApiClientConfig } from "../shared/generated";
-export declare class AuthManager extends BaseAPI implements AuthManagerInterface {
-    private readonly accessTokenUrl;
+import { AuthManagerInterface, BeginAuthSessionParams } from "../../private/model/AuthManagerInterface";
+declare class AuthManagerImpl implements AuthManagerInterface {
     private readonly authSessionMutex;
     private readonly contentType;
     private readonly contentTypeJson;
@@ -10,12 +8,18 @@ export declare class AuthManager extends BaseAPI implements AuthManagerInterface
     private readonly maxJwtTtlSeconds;
     private readonly retryAuthAfterErrorSeconds;
     private readonly refreshBeforeExpirySeconds;
-    constructor(config: BytescaleApiClientConfig);
+    constructor();
     isAuthSessionActive(): boolean;
-    beginAuthSession(authUrl: string, authHeaders: () => Promise<Record<string, string>>): Promise<void>;
+    beginAuthSession(params: BeginAuthSessionParams): Promise<void>;
     endAuthSession(): Promise<void>;
     private refreshAccessToken;
+    private getAccessTokenUrl;
     private deleteAccessToken;
     private setAccessToken;
     private getAccessToken;
 }
+/**
+ * Alternative way of implementing a static class (i.e. all methods static). We do this so we can use a interface on the class (interfaces can't define static methods).
+ */
+export declare const AuthManager: AuthManagerImpl;
+export {};

package/dist/types/public/browser/UploadManagerBrowser.d.ts

@@ -1,17 +1,8 @@
-import { UploadManagerBase } from "../../private/UploadManagerBase";
 import { UploadSourceProcessedBrowser } from "../../private/model/UploadSourceProcessed";
-import { PreUploadInfo } from "../../private/model/PreUploadInfo";
 import { UploadPart } from "../shared/generated";
 import { PutUploadPartResult } from "../../private/model/PutUploadPartResult";
 import { AddCancellationHandler } from "../../private/model/AddCancellationHandler";
-import { UploadManagerParams, UploadSource } from "../shared/CommonTypes";
-export declare class UploadManager extends UploadManagerBase<UploadSourceProcessedBrowser, undefined> {
-    protected processUploadSource(data: UploadSource): UploadSourceProcessedBrowser;
-    protected getPreUploadInfoPartial(_request: UploadManagerParams, data: UploadSourceProcessedBrowser): Partial<PreUploadInfo> & {
-        size: number;
-    };
-    protected preUpload(_source: UploadSourceProcessedBrowser): undefined;
-    protected postUpload(_init: undefined): Promise<void>;
-    protected doPutUploadPart(part: UploadPart, contentLength: number, source: UploadSourceProcessedBrowser, onProgress: (bytesSentDelta: number) => void, addCancellationHandler: AddCancellationHandler): Promise<PutUploadPartResult>;
-    private getRequestBody;
+import { UploadManagerBrowserWorkerBase } from "../../private/UploadManagerBrowserWorkerBase";
+export declare class UploadManager extends UploadManagerBrowserWorkerBase {
+    protected doPutUploadPart(part: UploadPart, _contentLength: number, source: UploadSourceProcessedBrowser, onProgress: (bytesSentDelta: number) => void, addCancellationHandler: AddCancellationHandler): Promise<PutUploadPartResult>;
 }

package/dist/types/public/node/AuthManagerNode.d.ts

@@ -1,6 +1,11 @@
-import { AuthManagerInterface } from "../../private/model/AuthManagerInterface";
-export declare class AuthManager implements AuthManagerInterface {
-    beginAuthSession(_authUrl: string, _authHeaders: () => Promise<Record<string, string>>): Promise<void>;
+import { AuthManagerInterface, BeginAuthSessionParams } from "../../private/model/AuthManagerInterface";
+declare class AuthManagerImpl implements AuthManagerInterface {
+    beginAuthSession(_params: BeginAuthSessionParams): Promise<void>;
     endAuthSession(): Promise<void>;
     isAuthSessionActive(): boolean;
 }
+/**
+ * Alternative way of implementing a static class (i.e. all methods static). We do this so we can use a interface on the class (interfaces can't define static methods).
+ */
+export declare const AuthManager: AuthManagerImpl;
+export {};

package/dist/types/public/shared/CommonTypes.d.ts

@@ -20,7 +20,6 @@ export interface UploadProgress {
 }
 export declare type UploadSource = NodeJS.ReadableStream | BlobLike | Buffer | string;
 export interface UploadManagerParams extends Omit<BeginMultipartUploadRequest, "size" | "protocol"> {
-    accountId: string;
     cancellationToken?: CancellationToken;
     data: UploadSource;
     maxConcurrentUploadParts?: number;

package/dist/types/public/shared/UrlBuilder.d.ts

@@ -1,7 +1,5 @@
-import { UrlBuilderConfig, UrlBuilderParams } from "./UrlBuilderTypes";
+import { UrlBuilderParams } from "./UrlBuilderTypes";
 export declare class UrlBuilder {
-    private readonly cdnUrl;
-    constructor(config?: UrlBuilderConfig);
     /**
      * Builds a URL to either a raw file or a transformed file.
      *
@@ -21,13 +19,13 @@ export declare class UrlBuilder {
      *
      *   new UrlBuilder().url({ accountId: "1234abc", filePath: "/example.jpg", options: { transformation: { type: "preset", preset: "thumbnail" } } })
      */
-    url(params: UrlBuilderParams): string;
-    private raw;
-    private transformation;
-    private getBaseUrl;
-    private getCommonTransformationQueryParams;
-    private getCommonQueryParams;
-    private makeQueryParams;
-    private getTransformationParams;
-    private addQueryParams;
+    static url(params: UrlBuilderParams): string;
+    private static raw;
+    private static transformation;
+    private static getBaseUrl;
+    private static getCommonTransformationQueryParams;
+    private static getCommonQueryParams;
+    private static makeQueryParams;
+    private static getTransformationParams;
+    private static addQueryParams;
 }

package/dist/types/public/shared/UrlBuilderTypes.d.ts

@@ -4,12 +4,6 @@
 export declare const UrlBuilderTypesNoOp = false;
 export declare type ParameterGroup = Record<string, string | number | boolean | undefined | null>;
 export declare type KeyValuePair = [string, string];
-export interface UrlBuilderConfig {
-    /**
-     * The base URL of the Bytescale CDN.
-     */
-    cdnUrl?: string;
-}
 export interface UrlBuilderParams {
     /**
      * The account that manages the file.

package/dist/types/public/shared/generated/runtime.d.ts

@@ -45,9 +45,9 @@ export declare class BytescaleApiClientConfigUtils {
     private static readonly specialApiKeyAccountId;
     private static readonly accountIdLength;
     static getApiUrl(config: BytescaleApiClientConfig): string;
-    static getCdnUrl(config: BytescaleApiClientConfig): string;
-    static getFetchApi(config: BytescaleApiClientConfig): FetchAPI;
-    static getAccountId(config: BytescaleApiClientConfig): string;
+    static getCdnUrl(config: Pick<BytescaleApiClientConfig, "cdnUrl">): string;
+    static getFetchApi(config: Pick<BytescaleApiClientConfig, "fetchApi">): FetchAPI;
+    static getAccountId(config: Pick<BytescaleApiClientConfig, "apiKey">): string;
     static validate(config: BytescaleApiClientConfig): void;
 }
 /**
@@ -56,11 +56,13 @@ export declare class BytescaleApiClientConfigUtils {
 export declare class BaseAPI {
     protected readonly config: BytescaleApiClientConfig;
     constructor(config: BytescaleApiClientConfig);
-    protected request(context: RequestOpts, initOverrides: RequestInit | InitOverrideFunction | undefined, baseUrlOverride: string | undefined): Promise<Response>;
     /**
      * Returns a successful response (2**) else throws an error.
      */
-    protected doFetch(url: string, init: RequestInit, isBytescaleApi: boolean): Promise<Response>;
+    static fetch(url: string, init: RequestInit, config: Pick<BytescaleApiClientConfig, "fetchApi"> & {
+        isBytescaleApi: boolean;
+    }): Promise<Response>;
+    protected request(context: RequestOpts, initOverrides: RequestInit | InitOverrideFunction | undefined, baseUrlOverride: string | undefined): Promise<Response>;
     protected encodeParam(paramName: string, paramValue: string): string;
     private createFetchParams;
 }

package/dist/types/public/worker/UploadManagerWorker.d.ts

@@ -0,0 +1,8 @@
+import { UploadSourceProcessedWorker } from "../../private/model/UploadSourceProcessed";
+import { UploadPart } from "../shared/generated";
+import { PutUploadPartResult } from "../../private/model/PutUploadPartResult";
+import { AddCancellationHandler } from "../../private/model/AddCancellationHandler";
+import { UploadManagerBrowserWorkerBase } from "../../private/UploadManagerBrowserWorkerBase";
+export declare class UploadManager extends UploadManagerBrowserWorkerBase {
+    protected doPutUploadPart(part: UploadPart, contentLength: number, source: UploadSourceProcessedWorker, _onProgress: (bytesSentDelta: number) => void, addCancellationHandler: AddCancellationHandler): Promise<PutUploadPartResult>;
+}

package/dist/types/public/worker/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./UploadManagerWorker";
+export * from "../node/AuthManagerNode";