@atlaskit/media-client 14.1.0 → 14.3.1

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

@@ -0,0 +1,103 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createMobileUploadService = createMobileUploadService;
+exports.createMobileUploadStateMachine = void 0;
+
+var _regenerator = _interopRequireDefault(require("@babel/runtime/regenerator"));
+
+var _asyncToGenerator2 = _interopRequireDefault(require("@babel/runtime/helpers/asyncToGenerator"));
+
+var _map = require("rxjs/operators/map");
+
+var _xstate = require("xstate");
+
+var _fileState = require("../../../models/file-state");
+
+var _shouldFetchRemoteFileStates3 = require("../../shouldFetchRemoteFileStates");
+
+var _helpers = require("../helpers");
+
+var _uploading = require("./states/uploading");
+
+var _processing = require("./states/processing");
+
+var _processed = require("./states/processed");
+
+var _processingFailed = require("./states/processingFailed");
+
+var _error = require("./states/error");
+
+var createMobileUploadStateMachine = function createMobileUploadStateMachine(dataloader, initialState, collectionName) {
+  return (0, _xstate.createMachine)({
+    // Initial state
+    initial: initialState.status,
+    // Context
+    context: {
+      currentFileState: initialState
+    },
+    // State definitions
+    states: {
+      uploading: _uploading.machineUploadingState,
+      processing: _processing.machineProcessingState,
+      processed: _processed.machineProcessedState,
+      processingFailed: _processingFailed.machineProcessingFailedState,
+      error: _error.machineErrorState
+    }
+  }, {
+    services: {
+      shouldFetchRemoteFileStates: function () {
+        var _shouldFetchRemoteFileStates2 = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee(ctx) {
+          var currentFileState, mediaType, mimeType, preview;
+          return _regenerator.default.wrap(function _callee$(_context) {
+            while (1) {
+              switch (_context.prev = _context.next) {
+                case 0:
+                  currentFileState = ctx.currentFileState;
+
+                  if (!(0, _fileState.isProcessingFileState)(currentFileState)) {
+                    _context.next = 4;
+                    break;
+                  }
+
+                  mediaType = currentFileState.mediaType, mimeType = currentFileState.mimeType, preview = currentFileState.preview;
+                  return _context.abrupt("return", (0, _shouldFetchRemoteFileStates3.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 (0, _helpers.createMobileDownloadFileStream)(dataloader, ctx.currentFileState.id, collectionName, ctx.currentFileState.occurrenceKey).pipe((0, _map.map)(function (fileState) {
+          return {
+            type: 'REMOTE_FILESTATE_RESULT',
+            fileState: fileState
+          };
+        }));
+      }
+    }
+  });
+};
+
+exports.createMobileUploadStateMachine = createMobileUploadStateMachine;
+
+function createMobileUploadService(machine) {
+  return (0, _xstate.interpret)(machine);
+}

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

@@ -0,0 +1,10 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.machineErrorState = void 0;
+var machineErrorState = {
+  type: 'final'
+};
+exports.machineErrorState = machineErrorState;

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

@@ -0,0 +1,10 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.machineProcessedState = void 0;
+var machineProcessedState = {
+  type: 'final'
+};
+exports.machineProcessedState = machineProcessedState;

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

@@ -0,0 +1,77 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.machineProcessingState = void 0;
+
+var _xstate = require("xstate");
+
+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: (0, _xstate.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: (0, _xstate.send)(function (ctx) {
+            return {
+              type: ctx.currentFileState.status === 'processed' ? 'REMOTE_FILESTATE_PROCESSED' : 'REMOTE_FILESTATE_PROCESSING_FAILED'
+            };
+          })
+        },
+        onError: {
+          actions: [(0, _xstate.assign)({
+            currentFileState: function currentFileState(ctx, event) {
+              return {
+                status: 'error',
+                id: ctx.currentFileState.id,
+                occurrenceKey: ctx.currentFileState.occurrenceKey,
+                message: event.data.message
+              };
+            }
+          }), (0, _xstate.send)({
+            type: 'REMOTE_FILESTATE_ERROR'
+          })]
+        }
+      },
+      on: {
+        REMOTE_FILESTATE_RESULT: {
+          actions: (0, _xstate.assign)({
+            currentFileState: function currentFileState(_, event) {
+              return event.fileState;
+            }
+          })
+        }
+      }
+    },
+    idle: {}
+  }
+};
+exports.machineProcessingState = machineProcessingState;

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

@@ -0,0 +1,10 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.machineProcessingFailedState = void 0;
+var machineProcessingFailedState = {
+  type: 'final'
+};
+exports.machineProcessingFailedState = machineProcessingFailedState;

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

@@ -0,0 +1,70 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.machineUploadingState = void 0;
+
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+
+var _xstate = require("xstate");
+
+var _fileState = require("../../../../models/file-state");
+
+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) { (0, _defineProperty2.default)(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; }
+
+var machineUploadingState = {
+  // Events
+  on: {
+    UPLOAD_PROGRESS: [{
+      target: 'uploading',
+      cond: function cond(ctx, event) {
+        return (0, _fileState.isUploadingFileState)(ctx.currentFileState) && event.progress > ctx.currentFileState.progress;
+      },
+      actions: (0, _xstate.assign)({
+        currentFileState: function currentFileState(ctx, event) {
+          return _objectSpread(_objectSpread({}, ctx.currentFileState), {}, {
+            progress: event.progress
+          });
+        }
+      })
+    }, {
+      target: 'error'
+    }],
+    UPLOAD_END: {
+      target: 'processing',
+      actions: (0, _xstate.assign)({
+        currentFileState: function currentFileState(ctx) {
+          return (0, _fileState.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: (0, _xstate.assign)({
+        currentFileState: function currentFileState(ctx, event) {
+          return {
+            status: 'error',
+            id: ctx.currentFileState.id,
+            message: event.message
+          };
+        }
+      })
+    }
+  }
+};
+exports.machineUploadingState = machineUploadingState;

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

@@ -0,0 +1,5 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});

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

@@ -17,19 +17,18 @@ var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/creat
 
 var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
 
-var _mediaFeatureFlags = require("@atlaskit/media-common/mediaFeatureFlags");
-
 var _errors = require("./errors");
 
 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) { (0, _defineProperty2.default)(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; }
 
+// default polling options without using feature flags
 var defaultPollingOptions = {
-  poll_intervalMs: (0, _mediaFeatureFlags.getMediaFeatureFlag)('poll_intervalMs'),
-  poll_maxAttempts: (0, _mediaFeatureFlags.getMediaFeatureFlag)('poll_maxAttempts'),
-  poll_backoffFactor: (0, _mediaFeatureFlags.getMediaFeatureFlag)('poll_backoffFactor'),
-  poll_maxIntervalMs: (0, _mediaFeatureFlags.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/cjs/version.json

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

package/dist/es2019/client/file-fetcher/index.js

@@ -28,22 +28,12 @@ import { isMimeTypeSupportedByBrowser, getMediaTypeFromMimeType } from '@atlaski
 import { shouldFetchRemoteFileStates, shouldFetchRemoteFileStatesObservable } from '../../utils/shouldFetchRemoteFileStates';
 import { PollingFunction } from '../../utils/polling';
 import { isEmptyFile } from '../../utils/detectEmptyFile';
-import { getMediaFeatureFlag } from '@atlaskit/media-common/mediaFeatureFlags';
 export { isFileFetcherError, FileFetcherError } from './error';
 export class FileFetcherImpl {
   constructor(mediaStore) {
     _defineProperty(this, "createDownloadFileStream", (id, collectionName, occurrenceKey) => {
       const subject = createFileStateSubject();
-      const {
-        featureFlags
-      } = this.mediaStore;
-      const pollingOptions = {
-        poll_intervalMs: getMediaFeatureFlag('poll_intervalMs', featureFlags),
-        poll_maxAttempts: getMediaFeatureFlag('poll_maxAttempts', featureFlags),
-        poll_backoffFactor: getMediaFeatureFlag('poll_backoffFactor', featureFlags),
-        poll_maxIntervalMs: getMediaFeatureFlag('poll_maxIntervalMs', featureFlags)
-      };
-      const poll = new PollingFunction(pollingOptions); // ensure subject errors if polling exceeds max iterations or uncaught exception in executor
+      const poll = new PollingFunction(); // ensure subject errors if polling exceeds max iterations or uncaught exception in executor
 
       poll.onError = error => subject.error(error);
 

package/dist/es2019/client/media-client.js

@@ -4,12 +4,14 @@ import { CollectionFetcher } from './collection-fetcher';
 import { FileFetcherImpl } from './file-fetcher';
 import { StargateClient } from './stargate-client';
 export class MediaClient {
+  // mobile upload is lazily loaded
   // Deprecated value introduced for backward compatibility with Context
   constructor(mediaClientConfig, featureFlags) {
     this.mediaClientConfig = mediaClientConfig;
     this.featureFlags = featureFlags;
     this.mediaStore = new MediaStore({
-      authProvider: mediaClientConfig.authProvider
+      authProvider: mediaClientConfig.authProvider,
+      initialAuth: mediaClientConfig.initialAuth
     }, featureFlags);
     this.config = mediaClientConfig;
     this.collection = new CollectionFetcher(this.mediaStore);
@@ -34,6 +36,18 @@ export class MediaClient {
     return (await this.mediaStore.getImageMetadata(id, params)).metadata;
   }
 
+  async mobileUploadPromise() {
+    if (this.mobileUpload) {
+      return this.mobileUpload;
+    }
+
+    const module = await import(
+    /* webpackChunkName: "@atlaskit-internal_media-client-mobile-upload" */
+    './mobile-upload');
+    this.mobileUpload = new module.MobileUploadImpl(this.mediaStore);
+    return this.mobileUpload;
+  }
+
   on(event, listener) {
     this.eventEmitter.on(event, listener);
   }

package/dist/es2019/client/media-store/resolveAuth.js

@@ -1,11 +1,11 @@
 import { MediaStoreError } from './error';
 import { rejectTimeout } from '../../utils/setTimeoutPromise';
-export const AUTH_PROVIDER_TIMEOUT = 10000;
-export const resolveAuth = async (authProvider, authContext) => {
+export const DEFAULT_AUTH_PROVIDER_TIMEOUT = 10000;
+export const resolveAuth = async (authProvider, authContext, authProviderTimeout = DEFAULT_AUTH_PROVIDER_TIMEOUT) => {
   let auth;
 
   try {
-    auth = await Promise.race([authProvider(authContext), rejectTimeout(AUTH_PROVIDER_TIMEOUT, new MediaStoreError('authProviderTimedOut'))]);
+    auth = await Promise.race([authProvider(authContext), rejectTimeout(authProviderTimeout, new MediaStoreError('authProviderTimedOut'))]);
   } catch (err) {
     if (err instanceof MediaStoreError) {
       throw err;

package/dist/es2019/client/mobile-upload.js

@@ -0,0 +1,80 @@
+import { getMediaTypeFromMimeType } from '@atlaskit/media-common';
+import { getFileStreamsCache } from '../file-streams-cache';
+import { createFileDataloader } from '../utils/createFileDataLoader';
+import { createServicesCache, createMobileUploadStateMachine, createMobileUploadService, createMobileFileStateSubject } from '../utils/mobileUpload';
+export class MobileUploadImpl {
+  constructor(mediaStore) {
+    this.dataloader = createFileDataloader(mediaStore);
+    this.servicesCache = createServicesCache();
+  }
+
+  notifyUploadStart(event) {
+    const {
+      fileId,
+      collectionName,
+      occurrenceKey,
+      fileName,
+      fileSize,
+      fileMimetype,
+      preview,
+      createdAt
+    } = event;
+    const mediaType = getMediaTypeFromMimeType(fileMimetype);
+    const initialState = {
+      status: 'uploading',
+      id: fileId,
+      occurrenceKey,
+      name: fileName,
+      size: fileSize,
+      progress: 0,
+      mediaType,
+      mimeType: fileMimetype,
+      preview,
+      createdAt
+    };
+    const service = createMobileUploadService(createMobileUploadStateMachine(this.dataloader, initialState, collectionName));
+    const subject = createMobileFileStateSubject(service);
+    this.servicesCache.put(fileId, service);
+    getFileStreamsCache().set(fileId, subject);
+  }
+
+  notifyUploadProgress(event) {
+    const {
+      fileId,
+      progress
+    } = event;
+    const service = this.servicesCache.get(fileId);
+
+    if (service) {
+      service.send('UPLOAD_PROGRESS', {
+        progress
+      });
+    }
+  }
+
+  notifyUploadEnd(event) {
+    const {
+      fileId
+    } = event;
+    const service = this.servicesCache.get(fileId);
+
+    if (service) {
+      service.send('UPLOAD_END');
+    }
+  }
+
+  notifyUploadError(event) {
+    const {
+      fileId,
+      message
+    } = event;
+    const service = this.servicesCache.get(fileId);
+
+    if (service) {
+      service.send('UPLOAD_ERROR', {
+        message
+      });
+    }
+  }
+
+}

package/dist/es2019/index.js

@@ -10,6 +10,7 @@ export { request, RequestError, isRequestError, isRateLimitedError } from './uti
 export { isAbortedRequestError, mapResponseToJson, mapResponseToBlob, mapResponseToVoid, createUrl } from './utils/request/helpers';
 export { PollingFunction } from './utils/polling';
 export { isPollingError, PollingError } from './utils/polling/errors';
+export { imageResizeModeToFileImageMode } from './utils/imageResizeModeToFileImageMode';
 export { FileFetcherImpl, FileFetcherError, isFileFetcherError } from './client/file-fetcher';
 export { CollectionFetcher } from './client/collection-fetcher';
 export { MediaClient } from './client/media-client';

package/dist/es2019/models/mobile-upload.js

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

package/dist/es2019/utils/imageResizeModeToFileImageMode.js

@@ -0,0 +1 @@
+export const imageResizeModeToFileImageMode = resizeMode => resizeMode === 'stretchy-fit' ? 'full-fit' : resizeMode;

package/dist/es2019/utils/mobileUpload/error.js

@@ -0,0 +1,30 @@
+import { BaseMediaClientError } from '../../models/errors';
+export class MobileUploadError extends BaseMediaClientError {
+  constructor(reason, id, metadata) {
+    super(reason);
+    this.reason = reason;
+    this.id = id;
+    this.metadata = metadata;
+  }
+
+  get attributes() {
+    const {
+      reason,
+      id,
+      metadata: {
+        collectionName,
+        occurrenceKey
+      } = {}
+    } = this;
+    return {
+      reason,
+      id,
+      collectionName,
+      occurrenceKey
+    };
+  }
+
+}
+export function isMobileUploadError(err) {
+  return err instanceof MobileUploadError;
+}

package/dist/es2019/utils/mobileUpload/helpers.js

@@ -0,0 +1,55 @@
+import { ReplaySubject } from 'rxjs/ReplaySubject';
+import { from } from 'rxjs/observable/from';
+import { map } from 'rxjs/operators/map';
+import { mapMediaItemToFileState } from '../../models/file-state';
+import { createFileStateSubject } from '../createFileStateSubject';
+import { isEmptyFile } from '../detectEmptyFile';
+import { PollingFunction } from '../polling';
+import { MobileUploadError } from './error';
+export const createMobileFileStateSubject = service => {
+  const subject = new ReplaySubject(1);
+  from(service.start()).pipe(map(state => state.context.currentFileState)).subscribe(subject);
+  return subject;
+};
+export const createMobileDownloadFileStream = (dataloader, id, collectionName, occurrenceKey) => {
+  const subject = createFileStateSubject();
+  const poll = new PollingFunction(); // ensure subject errors if polling exceeds max iterations or uncaught exception in executor
+
+  poll.onError = error => subject.error(error);
+
+  poll.execute(async () => {
+    const response = await dataloader.load({
+      id,
+      collectionName
+    });
+
+    if (!response) {
+      throw new MobileUploadError('emptyItems', id, {
+        collectionName,
+        occurrenceKey
+      });
+    }
+
+    if (isEmptyFile(response)) {
+      throw new MobileUploadError('zeroVersionFile', id, {
+        collectionName,
+        occurrenceKey
+      });
+    }
+
+    const fileState = mapMediaItemToFileState(id, response);
+    subject.next(fileState);
+
+    switch (fileState.status) {
+      case 'processing':
+        // the only case for continuing polling, otherwise this function is run once only
+        poll.next();
+        break;
+
+      case 'processed':
+        subject.complete();
+        break;
+    }
+  });
+  return subject;
+};

package/dist/es2019/utils/mobileUpload/index.js

@@ -0,0 +1,4 @@
+export { isMobileUploadError, MobileUploadError } from './error';
+export { createServicesCache } from './servicesCache';
+export { createMobileUploadService, createMobileUploadStateMachine } from './stateMachine';
+export { createMobileFileStateSubject } from './helpers';

package/dist/es2019/utils/mobileUpload/servicesCache.js

@@ -0,0 +1,4 @@
+import { LRUCache } from 'lru-fast';
+export function createServicesCache() {
+  return new LRUCache(100);
+}

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

@@ -0,0 +1,52 @@
+import { map } from 'rxjs/operators/map';
+import { createMachine, interpret } from 'xstate';
+import { isProcessingFileState } from '../../../models/file-state';
+import { 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 const createMobileUploadStateMachine = (dataloader, initialState, collectionName) => 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: async ctx => {
+      const {
+        currentFileState
+      } = ctx;
+
+      if (isProcessingFileState(currentFileState)) {
+        const {
+          mediaType,
+          mimeType,
+          preview
+        } = currentFileState;
+        return shouldFetchRemoteFileStates(mediaType, mimeType, preview);
+      }
+
+      return false;
+    },
+    fetchRemoteFileStates: ctx => createMobileDownloadFileStream(dataloader, ctx.currentFileState.id, collectionName, ctx.currentFileState.occurrenceKey).pipe(map(fileState => ({
+      type: 'REMOTE_FILESTATE_RESULT',
+      fileState
+    })))
+  }
+});
+export function createMobileUploadService(machine) {
+  return interpret(machine);
+}

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

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

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

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