@atlaskit/media-client 14.0.0 → 14.3.0

package/dist/esm/utils/mobileUpload/stateMachine/index.js

@@ -0,0 +1,78 @@
+import _regeneratorRuntime from "@babel/runtime/regenerator";
+import _asyncToGenerator from "@babel/runtime/helpers/asyncToGenerator";
+import { map } from 'rxjs/operators/map';
+import { createMachine, interpret } from 'xstate';
+import { isProcessingFileState } from '../../../models/file-state';
+import { shouldFetchRemoteFileStates as _shouldFetchRemoteFileStates } from '../../shouldFetchRemoteFileStates';
+import { createMobileDownloadFileStream } from '../helpers';
+import { machineUploadingState } from './states/uploading';
+import { machineProcessingState } from './states/processing';
+import { machineProcessedState } from './states/processed';
+import { machineProcessingFailedState } from './states/processingFailed';
+import { machineErrorState } from './states/error';
+export var createMobileUploadStateMachine = function createMobileUploadStateMachine(dataloader, initialState, collectionName) {
+  return createMachine({
+    // Initial state
+    initial: initialState.status,
+    // Context
+    context: {
+      currentFileState: initialState
+    },
+    // State definitions
+    states: {
+      uploading: machineUploadingState,
+      processing: machineProcessingState,
+      processed: machineProcessedState,
+      processingFailed: machineProcessingFailedState,
+      error: machineErrorState
+    }
+  }, {
+    services: {
+      shouldFetchRemoteFileStates: function () {
+        var _shouldFetchRemoteFileStates2 = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee(ctx) {
+          var currentFileState, mediaType, mimeType, preview;
+          return _regeneratorRuntime.wrap(function _callee$(_context) {
+            while (1) {
+              switch (_context.prev = _context.next) {
+                case 0:
+                  currentFileState = ctx.currentFileState;
+
+                  if (!isProcessingFileState(currentFileState)) {
+                    _context.next = 4;
+                    break;
+                  }
+
+                  mediaType = currentFileState.mediaType, mimeType = currentFileState.mimeType, preview = currentFileState.preview;
+                  return _context.abrupt("return", _shouldFetchRemoteFileStates(mediaType, mimeType, preview));
+
+                case 4:
+                  return _context.abrupt("return", false);
+
+                case 5:
+                case "end":
+                  return _context.stop();
+              }
+            }
+          }, _callee);
+        }));
+
+        function shouldFetchRemoteFileStates(_x) {
+          return _shouldFetchRemoteFileStates2.apply(this, arguments);
+        }
+
+        return shouldFetchRemoteFileStates;
+      }(),
+      fetchRemoteFileStates: function fetchRemoteFileStates(ctx) {
+        return createMobileDownloadFileStream(dataloader, ctx.currentFileState.id, collectionName, ctx.currentFileState.occurrenceKey).pipe(map(function (fileState) {
+          return {
+            type: 'REMOTE_FILESTATE_RESULT',
+            fileState: fileState
+          };
+        }));
+      }
+    }
+  });
+};
+export function createMobileUploadService(machine) {
+  return interpret(machine);
+}

package/dist/esm/utils/mobileUpload/stateMachine/states/error.js

@@ -0,0 +1,3 @@
+export var machineErrorState = {
+  type: 'final'
+};

package/dist/esm/utils/mobileUpload/stateMachine/states/processed.js

@@ -0,0 +1,3 @@
+export var machineProcessedState = {
+  type: 'final'
+};

package/dist/esm/utils/mobileUpload/stateMachine/states/processing.js

@@ -0,0 +1,68 @@
+import { assign, send } from 'xstate';
+export var machineProcessingState = {
+  // Events
+  on: {
+    REMOTE_FILESTATE_PROCESSED: 'processed',
+    REMOTE_FILESTATE_PROCESSING_FAILED: 'processingFailed',
+    REMOTE_FILESTATE_ERROR: 'error'
+  },
+  // Initial sub state
+  initial: 'loading',
+  // Sub states definitions
+  states: {
+    loading: {
+      invoke: {
+        src: 'shouldFetchRemoteFileStates',
+        onDone: {
+          actions: send(function (_, event) {
+            return {
+              // shouldFetchRemoteFileStates resolves a boolean
+              type: event.data ? 'REMOTE_FILESTATE_FETCH' : 'REMOTE_FILESTATE_BYPASS'
+            };
+          })
+        },
+        onError: 'idle'
+      },
+      on: {
+        REMOTE_FILESTATE_FETCH: 'fetchingRemoteFileStates',
+        REMOTE_FILESTATE_BYPASS: 'idle'
+      }
+    },
+    fetchingRemoteFileStates: {
+      invoke: {
+        src: 'fetchRemoteFileStates',
+        onDone: {
+          actions: send(function (ctx) {
+            return {
+              type: ctx.currentFileState.status === 'processed' ? 'REMOTE_FILESTATE_PROCESSED' : 'REMOTE_FILESTATE_PROCESSING_FAILED'
+            };
+          })
+        },
+        onError: {
+          actions: [assign({
+            currentFileState: function currentFileState(ctx, event) {
+              return {
+                status: 'error',
+                id: ctx.currentFileState.id,
+                occurrenceKey: ctx.currentFileState.occurrenceKey,
+                message: event.data.message
+              };
+            }
+          }), send({
+            type: 'REMOTE_FILESTATE_ERROR'
+          })]
+        }
+      },
+      on: {
+        REMOTE_FILESTATE_RESULT: {
+          actions: assign({
+            currentFileState: function currentFileState(_, event) {
+              return event.fileState;
+            }
+          })
+        }
+      }
+    },
+    idle: {}
+  }
+};

package/dist/esm/utils/mobileUpload/stateMachine/states/processingFailed.js

@@ -0,0 +1,3 @@
+export var machineProcessingFailedState = {
+  type: 'final'
+};

package/dist/esm/utils/mobileUpload/stateMachine/states/uploading.js

@@ -0,0 +1,58 @@
+import _defineProperty from "@babel/runtime/helpers/defineProperty";
+
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) { symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); } keys.push.apply(keys, symbols); } return keys; }
+
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
+
+import { assign } from 'xstate';
+import { isUploadingFileState } from '../../../../models/file-state';
+export var machineUploadingState = {
+  // Events
+  on: {
+    UPLOAD_PROGRESS: [{
+      target: 'uploading',
+      cond: function cond(ctx, event) {
+        return isUploadingFileState(ctx.currentFileState) && event.progress > ctx.currentFileState.progress;
+      },
+      actions: assign({
+        currentFileState: function currentFileState(ctx, event) {
+          return _objectSpread(_objectSpread({}, ctx.currentFileState), {}, {
+            progress: event.progress
+          });
+        }
+      })
+    }, {
+      target: 'error'
+    }],
+    UPLOAD_END: {
+      target: 'processing',
+      actions: assign({
+        currentFileState: function currentFileState(ctx) {
+          return isUploadingFileState(ctx.currentFileState) && {
+            status: 'processing',
+            id: ctx.currentFileState.id,
+            occurrenceKey: ctx.currentFileState.occurrenceKey,
+            name: ctx.currentFileState.name,
+            size: ctx.currentFileState.size,
+            mediaType: ctx.currentFileState.mediaType,
+            mimeType: ctx.currentFileState.mimeType,
+            preview: ctx.currentFileState.preview,
+            createdAt: ctx.currentFileState.createdAt
+          } || ctx.currentFileState;
+        }
+      })
+    },
+    UPLOAD_ERROR: {
+      target: 'error',
+      actions: assign({
+        currentFileState: function currentFileState(ctx, event) {
+          return {
+            status: 'error',
+            id: ctx.currentFileState.id,
+            message: event.message
+          };
+        }
+      })
+    }
+  }
+};

package/dist/esm/utils/mobileUpload/stateMachine/types.js

@@ -0,0 +1 @@
+export {};

package/dist/esm/utils/polling/index.js

@@ -8,13 +8,13 @@ function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (O
 
 function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
 
-import { getMediaFeatureFlag } from '@atlaskit/media-common/mediaFeatureFlags';
 import { PollingError } from './errors';
+// default polling options without using feature flags
 export var defaultPollingOptions = {
-  poll_intervalMs: getMediaFeatureFlag('poll_intervalMs'),
-  poll_maxAttempts: getMediaFeatureFlag('poll_maxAttempts'),
-  poll_backoffFactor: getMediaFeatureFlag('poll_backoffFactor'),
-  poll_maxIntervalMs: getMediaFeatureFlag('poll_maxIntervalMs')
+  poll_intervalMs: 3000,
+  poll_maxAttempts: 30,
+  poll_backoffFactor: 1.25,
+  poll_maxIntervalMs: 200000
 };
 /**
  * This class encapsulates polling functionality with the following features:

package/dist/esm/utils/setTimeoutPromise.js

@@ -0,0 +1,10 @@
+export var resolveTimeout = function resolveTimeout(timeout, resolveWith) {
+  return new Promise(function (resolve, _reject) {
+    setTimeout(resolve, timeout, resolveWith);
+  });
+};
+export var rejectTimeout = function rejectTimeout(timeout, rejectWith) {
+  return new Promise(function (_resolve, reject) {
+    setTimeout(reject, timeout, rejectWith);
+  });
+};

package/dist/esm/version.json

@@ -1,5 +1,5 @@
 {
 	"name": "@atlaskit/media-client",
-	"version": "14.0.0",
+	"version": "14.3.0",
 	"sideEffects": false
 }

package/dist/types/client/file-fetcher/index.d.ts

@@ -1,4 +1,5 @@
 import { ReplaySubject } from 'rxjs/ReplaySubject';
+import 'setimmediate';
 import { AuthProvider } from '@atlaskit/media-core';
 import { MediaStore, MediaStoreCopyFileWithTokenParams, TouchedFiles, TouchFileDescriptor } from '../media-store';
 import { FilePreview, FileState, GetFileOptions } from '../../models/file-state';

package/dist/types/client/media-client.d.ts

@@ -5,6 +5,7 @@ import { CollectionFetcher } from './collection-fetcher';
 import { FileFetcher } from './file-fetcher';
 import { UploadEventPayloadMap, EventPayloadListener } from './events';
 import { StargateClient } from './stargate-client';
+import { MobileUpload } from '../models/mobile-upload';
 export declare class MediaClient {
     readonly mediaClientConfig: MediaClientConfig;
     readonly featureFlags?: MediaFeatureFlags | undefined;
@@ -13,12 +14,14 @@ export declare class MediaClient {
     readonly file: FileFetcher;
     readonly stargate: StargateClient;
     private readonly eventEmitter;
+    private mobileUpload?;
     readonly config: MediaClientConfig;
     constructor(mediaClientConfig: MediaClientConfig, featureFlags?: MediaFeatureFlags | undefined);
     getImage(id: string, params?: MediaStoreGetFileImageParams, controller?: AbortController, fetchMaxRes?: boolean): Promise<Blob>;
     getImageUrl(id: string, params?: MediaStoreGetFileImageParams): Promise<string>;
     getImageUrlSync(id: string, params?: MediaStoreGetFileImageParams): string;
     getImageMetadata(id: string, params?: MediaStoreGetFileImageParams): Promise<ImageMetadata>;
+    mobileUploadPromise(): Promise<MobileUpload>;
     on<E extends keyof UploadEventPayloadMap>(event: E, listener: EventPayloadListener<UploadEventPayloadMap, E>): void;
     off<E extends keyof UploadEventPayloadMap>(event: E, listener: EventPayloadListener<UploadEventPayloadMap, E>): void;
     emit<E extends keyof UploadEventPayloadMap>(event: E, payload: UploadEventPayloadMap[E]): boolean;

package/dist/types/client/media-store/error.d.ts

@@ -1,5 +1,5 @@
 import { BaseMediaClientError } from '../../models/errors';
-export declare type MediaStoreErrorReason = 'failedAuthProvider' | 'tokenExpired' | 'missingInitialAuth';
+export declare type MediaStoreErrorReason = 'failedAuthProvider' | 'tokenExpired' | 'missingInitialAuth' | 'emptyAuth' | 'authProviderTimedOut';
 export declare type MediaStoreErrorAttributes = {
     readonly reason: MediaStoreErrorReason;
     readonly innerError?: Error;

package/dist/types/client/media-store/resolveAuth.d.ts

@@ -1,4 +1,4 @@
 import { Auth, AuthContext, AuthProvider } from '@atlaskit/media-core';
-export declare const TOKEN_MINIMUM_LIFETIME = 10000;
-export declare const resolveAuth: (authProvider: AuthProvider, authContext?: AuthContext | undefined) => Promise<Auth>;
+export declare const DEFAULT_AUTH_PROVIDER_TIMEOUT = 10000;
+export declare const resolveAuth: (authProvider: AuthProvider, authContext?: AuthContext | undefined, authProviderTimeout?: number) => Promise<Auth>;
 export declare const resolveInitialAuth: (auth?: import("@atlaskit/media-core").ClientBasedAuth | import("@atlaskit/media-core").AsapBasedAuth | undefined) => Auth;

package/dist/types/client/mobile-upload.d.ts

@@ -0,0 +1,11 @@
+import { MobileUpload, MobileUploadStartEvent, MobileUploadProgressEvent, MobileUploadEndEvent, MobileUploadErrorEvent } from '../models/mobile-upload';
+import { MediaStore } from './media-store';
+export declare class MobileUploadImpl implements MobileUpload {
+    private readonly dataloader;
+    private readonly servicesCache;
+    constructor(mediaStore: MediaStore);
+    notifyUploadStart(event: MobileUploadStartEvent): void;
+    notifyUploadProgress(event: MobileUploadProgressEvent): void;
+    notifyUploadEnd(event: MobileUploadEndEvent): void;
+    notifyUploadError(event: MobileUploadErrorEvent): void;
+}

package/dist/types/index.d.ts

@@ -11,6 +11,7 @@ export { isMediaClientError, getMediaClientErrorReason } from './models/errors';
 export type { MediaClientError, MediaClientErrorReason, MediaClientErrorAttributes, } from './models/errors';
 export { isUploadingFileState, isProcessingFileState, isProcessedFileState, isErrorFileState, isPreviewableFileState, isFinalFileState, isImageRepresentationReady, mapMediaFileToFileState, mapMediaItemToFileState, } from './models/file-state';
 export type { FileStatus, FilePreview, PreviewOptions, GetFileOptions, UploadingFileState, ProcessingFileState, ProcessedFileState, ProcessingFailedState, ErrorFileState, NonErrorFileState, PreviewableFileState, FileState, } from './models/file-state';
+export type { MobileUploadStartEvent, MobileUploadProgressEvent, MobileUploadEndEvent, MobileUploadErrorEvent, } from './models/mobile-upload';
 export { getFileStreamsCache, StreamsCache } from './file-streams-cache';
 export { uploadFile } from './uploader';
 export type { UploadableFile, UploadableFileUpfrontIds, UploadFileCallbacks, UploadFileResult, } from './uploader';
@@ -21,7 +22,8 @@ export { PollingFunction } from './utils/polling';
 export { isPollingError, PollingError } from './utils/polling/errors';
 export type { Executor, PollingErrorAttributes, PollingErrorReason, } from './utils/polling/types';
 export type { RequestMethod, RequestParams, RequestHeaders, RetryOptions, ClientOptions, RequestMetadata, RequestOptions, CreateUrlOptions, } from './utils/request/types';
-export declare type ImageResizeMode = 'crop' | 'fit' | 'full-fit' | 'stretchy-fit';
+export type { ImageResizeMode } from './utils/imageResizeModeToFileImageMode';
+export { imageResizeModeToFileImageMode } from './utils/imageResizeModeToFileImageMode';
 export { FileFetcherImpl, FileFetcherError, isFileFetcherError, } from './client/file-fetcher';
 export type { CopySourceFile, CopyDestination, CopyFileOptions, FileFetcher, FileFetcherErrorAttributes, FileFetcherErrorReason, } from './client/file-fetcher';
 export { CollectionFetcher } from './client/collection-fetcher';

package/dist/types/models/errors/types.d.ts

@@ -1,4 +1,4 @@
-export declare type MediaClientErrorReason = 'clientOffline' | 'clientAbortedRequest' | 'clientTimeoutRequest' | 'serverInvalidBody' | 'serverBadRequest' | 'serverUnauthorized' | 'serverForbidden' | 'serverNotFound' | 'serverRateLimited' | 'serverInternalError' | 'serverBadGateway' | 'serverUnexpectedError' | 'failedAuthProvider' | 'tokenExpired' | 'missingInitialAuth' | 'invalidFileId' | 'emptyItems' | 'zeroVersionFile' | 'pollingMaxAttemptsExceeded';
+export declare type MediaClientErrorReason = 'clientOffline' | 'clientAbortedRequest' | 'clientTimeoutRequest' | 'serverInvalidBody' | 'serverBadRequest' | 'serverUnauthorized' | 'serverForbidden' | 'serverNotFound' | 'serverRateLimited' | 'serverInternalError' | 'serverBadGateway' | 'serverUnexpectedError' | 'failedAuthProvider' | 'tokenExpired' | 'missingInitialAuth' | 'emptyAuth' | 'authProviderTimedOut' | 'invalidFileId' | 'emptyItems' | 'zeroVersionFile' | 'pollingMaxAttemptsExceeded';
 export interface MediaClientErrorAttributes {
     reason: MediaClientErrorReason;
 }

package/dist/types/models/mobile-upload.d.ts

@@ -0,0 +1,28 @@
+import { FilePreview } from './file-state';
+export declare type MobileUploadStartEvent = {
+    fileId: string;
+    collectionName?: string;
+    occurrenceKey?: string;
+    fileName: string;
+    fileSize: number;
+    fileMimetype: string;
+    preview?: FilePreview;
+    createdAt?: number;
+};
+export declare type MobileUploadProgressEvent = {
+    fileId: string;
+    progress: number;
+};
+export declare type MobileUploadEndEvent = {
+    fileId: string;
+};
+export declare type MobileUploadErrorEvent = {
+    fileId: string;
+    message: string;
+};
+export interface MobileUpload {
+    notifyUploadStart(event: MobileUploadStartEvent): void;
+    notifyUploadProgress(event: MobileUploadProgressEvent): void;
+    notifyUploadEnd(event: MobileUploadEndEvent): void;
+    notifyUploadError(event: MobileUploadErrorEvent): void;
+}

package/dist/types/utils/createFileDataLoader.d.ts

@@ -1,3 +1,4 @@
+import 'setimmediate';
 import Dataloader from 'dataloader';
 import { MediaStore, ResponseFileItem } from '../client/media-store';
 import { MediaCollectionItemFullDetails } from '../models/media';
@@ -12,7 +13,7 @@ export declare type BatchLoadingErrorResult = {
     readonly collection?: string;
     readonly error: Error;
 };
-export declare const getItemsFromKeys: (dataloaderKeys: DataloaderKey[], fileItems: Array<ResponseFileItem | BatchLoadingErrorResult>) => Array<DataloaderResult | Error>;
+export declare const getItemsFromKeys: (dataloaderKeys: ReadonlyArray<DataloaderKey>, fileItems: Array<ResponseFileItem | BatchLoadingErrorResult>) => Array<DataloaderResult | Error>;
 export declare type FileIdsByCollection = {
     [collectionName: string]: string[];
 };
@@ -25,5 +26,5 @@ export declare type FileIdsByCollection = {
  *
  * @param mediaStore instance of MediaStore
  */
-export declare function createBatchLoadingFunc(mediaStore: MediaStore): (keys: DataloaderKey[]) => Promise<Array<DataloaderResult | Error>>;
-export declare function createFileDataloader(mediaStore: MediaStore): Dataloader<DataloaderKey, DataloaderResult>;
+export declare function createBatchLoadingFunc(mediaStore: MediaStore): (keys: ReadonlyArray<DataloaderKey>) => Promise<Array<DataloaderResult | Error>>;
+export declare function createFileDataloader(mediaStore: MediaStore): Dataloader<DataloaderKey, DataloaderResult, DataloaderKey>;

package/dist/types/utils/imageResizeModeToFileImageMode.d.ts

@@ -0,0 +1,3 @@
+import { MediaStoreGetFileImageParams } from '../client/media-store';
+export declare type ImageResizeMode = 'crop' | 'fit' | 'full-fit' | 'stretchy-fit';
+export declare const imageResizeModeToFileImageMode: (resizeMode?: "crop" | "fit" | "full-fit" | "stretchy-fit" | undefined) => MediaStoreGetFileImageParams['mode'];

package/dist/types/utils/mobileUpload/error.d.ts

@@ -0,0 +1,29 @@
+import { BaseMediaClientError } from '../../models/errors';
+export declare type MobileUploadErrorReason = 'emptyItems' | 'zeroVersionFile';
+export declare type MobileUploadErrorAttributes = {
+    readonly reason: MobileUploadErrorReason;
+    readonly id: string;
+    readonly metadata?: {
+        readonly collectionName?: string;
+        readonly occurrenceKey?: string;
+    };
+};
+export declare class MobileUploadError extends BaseMediaClientError<MobileUploadErrorAttributes> {
+    readonly reason: MobileUploadErrorReason;
+    readonly id: string;
+    readonly metadata?: {
+        readonly collectionName?: string | undefined;
+        readonly occurrenceKey?: string | undefined;
+    } | undefined;
+    constructor(reason: MobileUploadErrorReason, id: string, metadata?: {
+        readonly collectionName?: string | undefined;
+        readonly occurrenceKey?: string | undefined;
+    } | undefined);
+    get attributes(): {
+        reason: MobileUploadErrorReason;
+        id: string;
+        collectionName: string | undefined;
+        occurrenceKey: string | undefined;
+    };
+}
+export declare function isMobileUploadError(err: Error): err is MobileUploadError;

package/dist/types/utils/mobileUpload/helpers.d.ts

@@ -0,0 +1,8 @@
+import Dataloader from 'dataloader';
+import { ReplaySubject } from 'rxjs/ReplaySubject';
+import { Interpreter } from 'xstate';
+import { FileState } from '../../models/file-state';
+import { DataloaderKey, DataloaderResult } from '../createFileDataLoader';
+import { StateMachineContext, StateMachineEvent, StateMachineTypestate } from './stateMachine/types';
+export declare const createMobileFileStateSubject: (service: Interpreter<StateMachineContext, any, StateMachineEvent, StateMachineTypestate>) => ReplaySubject<FileState>;
+export declare const createMobileDownloadFileStream: (dataloader: Dataloader<DataloaderKey, DataloaderResult>, id: string, collectionName?: string | undefined, occurrenceKey?: string | undefined) => ReplaySubject<FileState>;

package/dist/types/utils/mobileUpload/index.d.ts

@@ -0,0 +1,5 @@
+export { isMobileUploadError, MobileUploadError } from './error';
+export { createServicesCache } from './servicesCache';
+export { createMobileUploadService, createMobileUploadStateMachine, } from './stateMachine';
+export { createMobileFileStateSubject } from './helpers';
+export type { StateMachineContext, StateMachineSchema, StateMachineEvent, StateMachineTypestate, } from './stateMachine/types';

package/dist/types/utils/mobileUpload/servicesCache.d.ts

@@ -0,0 +1,4 @@
+import { LRUCache } from 'lru-fast';
+import { Interpreter } from 'xstate';
+import { StateMachineContext, StateMachineEvent, StateMachineTypestate } from './stateMachine/types';
+export declare function createServicesCache(): LRUCache<string, Interpreter<StateMachineContext, any, StateMachineEvent, StateMachineTypestate>>;

package/dist/types/utils/mobileUpload/stateMachine/index.d.ts

@@ -0,0 +1,7 @@
+import DataLoader from 'dataloader';
+import { Interpreter, StateMachine } from 'xstate';
+import { UploadingFileState } from '../../../models/file-state';
+import { DataloaderKey, DataloaderResult } from '../../createFileDataLoader';
+import { StateMachineContext, StateMachineEvent, StateMachineSchema, StateMachineTypestate } from './types';
+export declare const createMobileUploadStateMachine: (dataloader: DataLoader<DataloaderKey, DataloaderResult>, initialState: UploadingFileState, collectionName?: string | undefined) => StateMachine<StateMachineContext, any, StateMachineEvent, StateMachineTypestate>;
+export declare function createMobileUploadService(machine: StateMachine<StateMachineContext, StateMachineSchema, StateMachineEvent, StateMachineTypestate>): Interpreter<StateMachineContext, StateMachineSchema, StateMachineEvent, StateMachineTypestate>;

package/dist/types/utils/mobileUpload/stateMachine/states/error.d.ts

@@ -0,0 +1,3 @@
+import { StateNodeConfig } from 'xstate';
+import { StateMachineContext, StateMachineSchema, StateMachineEvent } from '../types';
+export declare const machineErrorState: StateNodeConfig<StateMachineContext, StateMachineSchema, StateMachineEvent>;

package/dist/types/utils/mobileUpload/stateMachine/states/processed.d.ts

@@ -0,0 +1,3 @@
+import { StateNodeConfig } from 'xstate';
+import { StateMachineContext, StateMachineSchema, StateMachineEvent } from '../types';
+export declare const machineProcessedState: StateNodeConfig<StateMachineContext, StateMachineSchema, StateMachineEvent>;

package/dist/types/utils/mobileUpload/stateMachine/states/processing.d.ts

@@ -0,0 +1,3 @@
+import { StateNodeConfig } from 'xstate';
+import { ProcessingStateMachineSchema, StateMachineContext, StateMachineEvent } from '../types';
+export declare const machineProcessingState: StateNodeConfig<StateMachineContext, ProcessingStateMachineSchema, StateMachineEvent>;

package/dist/types/utils/mobileUpload/stateMachine/states/processingFailed.d.ts

@@ -0,0 +1,3 @@
+import { StateNodeConfig } from 'xstate';
+import { StateMachineContext, StateMachineSchema, StateMachineEvent } from '../types';
+export declare const machineProcessingFailedState: StateNodeConfig<StateMachineContext, StateMachineSchema, StateMachineEvent>;

package/dist/types/utils/mobileUpload/stateMachine/states/uploading.d.ts

@@ -0,0 +1,3 @@
+import { StateNodeConfig } from 'xstate';
+import { StateMachineContext, StateMachineSchema, StateMachineEvent } from '../types';
+export declare const machineUploadingState: StateNodeConfig<StateMachineContext, StateMachineSchema, StateMachineEvent>;

package/dist/types/utils/mobileUpload/stateMachine/types.d.ts

@@ -0,0 +1,69 @@
+import { StateSchema } from 'xstate';
+import { FileState, UploadingFileState, ProcessingFileState, ProcessedFileState, ErrorFileState, ProcessingFailedState } from '../../../models/file-state';
+export declare type StateMachineContext = {
+    currentFileState: FileState;
+};
+export declare type StateMachineEvent = {
+    type: 'UPLOAD_PROGRESS';
+    progress: number;
+} | {
+    type: 'UPLOAD_END';
+} | {
+    type: 'UPLOAD_ERROR';
+    message: string;
+} | {
+    type: 'REMOTE_FILESTATE_FETCH';
+} | {
+    type: 'REMOTE_FILESTATE_BYPASS';
+} | {
+    type: 'REMOTE_FILESTATE_RESULT';
+    fileState: FileState;
+} | {
+    type: 'REMOTE_FILESTATE_PROCESSED';
+} | {
+    type: 'REMOTE_FILESTATE_PROCESSING_FAILED';
+} | {
+    type: 'REMOTE_FILESTATE_ERROR';
+};
+export declare type ProcessingStateMachineSchema = StateSchema<StateMachineContext> & {
+    states: {
+        loading: StateSchema<StateMachineContext>;
+        fetchingRemoteFileStates: StateSchema<StateMachineContext>;
+        idle: StateSchema<StateMachineContext>;
+    };
+};
+export declare type StateMachineSchema = StateSchema<StateMachineContext> & {
+    states: {
+        uploading: StateSchema<StateMachineContext>;
+        processing: ProcessingStateMachineSchema;
+        processed: StateSchema<StateMachineContext>;
+        processingFailed: StateSchema<StateMachineContext>;
+        error: StateSchema<StateMachineContext>;
+    };
+};
+export declare type StateMachineTypestate = {
+    value: 'uploading';
+    context: {
+        currentFileState: UploadingFileState;
+    };
+} | {
+    value: 'processing';
+    context: {
+        currentFileState: ProcessingFileState;
+    };
+} | {
+    value: 'processed';
+    context: {
+        currentFileState: ProcessedFileState;
+    };
+} | {
+    value: 'processingFailed';
+    context: {
+        currentFileState: ProcessingFailedState;
+    };
+} | {
+    value: 'error';
+    context: {
+        currentFileState: ErrorFileState;
+    };
+};

package/dist/types/utils/polling/index.d.ts

@@ -1,6 +1,11 @@
-import { PollingOptions } from '@atlaskit/media-common/mediaFeatureFlags';
 import { Executor } from './types';
-export declare const defaultPollingOptions: Required<PollingOptions>;
+export interface PollingOptions {
+    poll_intervalMs: number;
+    poll_maxAttempts: number;
+    poll_backoffFactor: number;
+    poll_maxIntervalMs: number;
+}
+export declare const defaultPollingOptions: PollingOptions;
 /**
  * This class encapsulates polling functionality with the following features:
  *
@@ -13,7 +18,7 @@ export declare const defaultPollingOptions: Required<PollingOptions>;
  * IMPORTANT! the executor function must explicitly call ".next()" for the next iteration to run
  */
 export declare class PollingFunction {
-    options: Required<PollingOptions>;
+    options: PollingOptions;
     poll_intervalMs: number;
     attempt: number;
     shouldIterate: boolean;

package/dist/types/utils/setTimeoutPromise.d.ts

@@ -0,0 +1,2 @@
+export declare const resolveTimeout: <T>(timeout: number, resolveWith: T) => Promise<T>;
+export declare const rejectTimeout: (timeout: number, rejectWith: Error) => Promise<undefined>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@atlaskit/media-client",
-  "version": "14.0.0",
+  "version": "14.3.0",
   "description": "Media API Web Client Library",
   "publishConfig": {
     "registry": "https://registry.npmjs.org/"
@@ -28,17 +28,19 @@
   },
   "dependencies": {
     "@atlaskit/chunkinator": "^3.0.0",
-    "@atlaskit/media-common": "^2.8.0",
+    "@atlaskit/media-common": "^2.9.0",
     "@babel/runtime": "^7.0.0",
-    "dataloader": "^1.4.0",
+    "dataloader": "^2.0.0",
     "deep-equal": "^1.0.1",
     "eventemitter2": "^4.1.0",
     "lru-fast": "^0.2.2",
     "query-string": "^5.1.0",
     "rusha": "^0.8.13",
+    "setimmediate": "^1.0.5",
     "uuid": "^3.1.0",
     "uuid-validate": "^0.0.3",
-    "video-snapshot": "^1.0.11"
+    "video-snapshot": "^1.0.11",
+    "xstate": "^4.20.0"
   },
   "peerDependencies": {
     "@atlaskit/media-core": "^32.2.0",
@@ -47,11 +49,11 @@
   },
   "devDependencies": {
     "@atlaskit/build-utils": "*",
-    "@atlaskit/button": "^16.0.0",
+    "@atlaskit/button": "^16.1.0",
     "@atlaskit/docs": "*",
-    "@atlaskit/media-card": "^70.9.0",
+    "@atlaskit/media-card": "^72.0.0",
     "@atlaskit/media-core": "^32.2.0",
-    "@atlaskit/media-test-helpers": "^28.7.0",
+    "@atlaskit/media-test-helpers": "^28.8.0",
     "@atlaskit/ssr": "*",
     "@atlassian/atlassian-frontend-prettier-config-1.0.1": "npm:@atlassian/atlassian-frontend-prettier-config@1.0.1",
     "@types/deep-equal": "^1.0.1",