@atlaskit/media-client 37.2.37 → 37.3.0

package/dist/es2019/models/media.js

@@ -1,16 +1,20 @@
+/* eslint-disable @repo/internal/deprecations/deprecation-ticket-required -- VOLTC-139 tracks removal of these deprecated re-export shims. */
+
 // Warning! You can't add new media file processing status!
 // See packages/media/media-core/src/__tests__/cache-backward-compatibility.spec.ts
 
-export const isPreviewableType = type => {
-  const defaultPreviewableTypes = ['audio', 'video', 'image', 'doc'];
-  return defaultPreviewableTypes.indexOf(type) > -1;
-};
-export const isNotFoundMediaItemDetails = itemDetails => {
-  return 'type' in itemDetails && itemDetails.type === 'not-found';
-};
 export let DATA_UNIT = /*#__PURE__*/function (DATA_UNIT) {
   DATA_UNIT[DATA_UNIT["MB"] = 1048576] = "MB";
   DATA_UNIT[DATA_UNIT["GB"] = 1073741824] = "GB";
   DATA_UNIT[DATA_UNIT["TB"] = 1099511627776] = "TB";
   return DATA_UNIT;
-}({});
+}({});
+
+/**
+ * @deprecated Use `import { isPreviewableType } from '@atlaskit/media-client'` instead.
+ */
+export { isPreviewableType } from './is-previewable-type';
+/**
+ * @deprecated Use `import { isNotFoundMediaItemDetails } from '@atlaskit/media-client/media'` instead.
+ */
+export { isNotFoundMediaItemDetails } from './is-not-found-media-item-details';

package/dist/es2019/uploader/{error.js → UploaderError.js}

@@ -1,4 +1,4 @@
-import { BaseMediaClientError } from '../models/errors';
+import { BaseMediaClientError } from '../models/errors/BaseMediaClientError';
 export class UploaderError extends BaseMediaClientError {
   // Legacy Attribute. Should be removed
 
@@ -25,7 +25,4 @@ export class UploaderError extends BaseMediaClientError {
       occurrenceKey
     };
   }
-}
-export function isUploaderError(err) {
-  return err instanceof UploaderError;
 }

package/dist/es2019/uploader/index.js

@@ -1,9 +1,9 @@
-import { chunkinator } from '@atlaskit/chunkinator';
 import { from } from 'rxjs/observable/from';
 import { concatMap } from 'rxjs/operators/concatMap';
-import { createHasher } from '../utils/hashing/hasherCreator';
-import { UploaderError } from './error';
+import { chunkinator } from '@atlaskit/chunkinator';
 import { CHUNK_SIZE, PROCESSING_BATCH_SIZE } from '../constants';
+import { createHasher } from '../utils/hashing/hasherCreator';
+import { UploaderError } from './UploaderError';
 import { calculateChunkSize, fileSizeError } from './calculateChunkSize';
 
 // TODO: Allow to pass multiple files

package/dist/es2019/uploader/isUploaderError.js

@@ -0,0 +1,4 @@
+import { UploaderError } from './UploaderError';
+export function isUploaderError(err) {
+  return err instanceof UploaderError;
+}

package/dist/es2019/utils/addFileAttrsToUrl.js

@@ -0,0 +1,19 @@
+import { objectToQueryString } from './objectToQueryString';
+import { mediaBlobUrlIdentifier } from './url';
+export const addFileAttrsToUrl = (url, fileAttrs) => {
+  const isSafari = /^((?!chrome|android).)*safari/i.test(navigator.userAgent);
+  if (isSafari) {
+    return url;
+  }
+  const mediaIdentifierAttr = {
+    [mediaBlobUrlIdentifier]: 'true'
+  };
+  const mergedAttrs = {
+    ...mediaIdentifierAttr,
+    ...fileAttrs
+  };
+  const queryAttrs = objectToQueryString(mergedAttrs);
+
+  // we can't use '?' separator for blob url params
+  return `${url}#${queryAttrs}`;
+};

package/dist/es2019/utils/createBatchLoadingFunc.js

@@ -0,0 +1,74 @@
+import { getRandomTelemetryId } from '@atlaskit/media-common';
+import { getItemsFromKeys } from './getItemsFromKeys';
+
+/**
+ * Returns a function that, given Array<DataloaderKey>, resolves to an array of same length containing either DataloaderResult or Error.
+ * Such contract is formalised by Dataloader 1.0, @see https://github.com/graphql/dataloader
+ *
+ * If an Error is resolved in the results, it must be at same position then their corresponding key:
+ * - Dataloader will re-throw that Error when accessing/loading that particular key
+ *
+ * @param mediaStore instance of MediaStore
+ */
+export function createBatchLoadingFunc(mediaStore) {
+  return async keys => {
+    const nonCollectionName = '__media-single-file-collection__';
+    const includeHashByCollection = keys.reduce((acc, key) => {
+      const collectionName = key.collectionName || nonCollectionName;
+      if (key.includeHashForDuplicateFiles) {
+        acc[collectionName] = key.includeHashForDuplicateFiles;
+      }
+      return acc;
+    }, {});
+    const fileIdsByCollection = keys.reduce((acc, key) => {
+      const collectionName = key.collectionName || nonCollectionName;
+      const fileIds = acc[collectionName] || [];
+
+      // de-duplicate ids in collection
+      if (fileIds.indexOf(key.id) === -1) {
+        fileIds.push(key.id);
+      }
+      acc[collectionName] = fileIds;
+      return acc;
+    }, {});
+    const items = [];
+    await Promise.all(Object.keys(fileIdsByCollection).map(async collectionNameKey => {
+      const metadataTraceContext = {
+        traceId: getRandomTelemetryId(),
+        spanId: getRandomTelemetryId()
+      };
+      const fileIds = fileIdsByCollection[collectionNameKey];
+      const includeHashForDuplicateFiles = includeHashByCollection[collectionNameKey];
+      const collectionName = collectionNameKey === nonCollectionName ? undefined : collectionNameKey;
+      try {
+        const response = await mediaStore.getItems(fileIds, collectionName, metadataTraceContext, includeHashForDuplicateFiles);
+        const itemsWithMetadataTraceContext = response.data.items.map(item => ({
+          ...item,
+          metadataTraceContext
+        }));
+        items.push(...itemsWithMetadataTraceContext);
+
+        // add EmptyResponseFileItem for each file ID not included in /items response
+        const itemsIds = itemsWithMetadataTraceContext.map(item => item.id);
+        const fileIdsNotFound = fileIds.filter(id => !itemsIds.includes(id));
+        fileIdsNotFound.forEach(fileId => {
+          items.push({
+            id: fileId,
+            collection: collectionName,
+            type: 'not-found',
+            metadataTraceContext
+          });
+        });
+      } catch (error) {
+        fileIds.forEach(fileId => {
+          items.push({
+            id: fileId,
+            collection: collectionName,
+            error: error
+          });
+        });
+      }
+    }));
+    return getItemsFromKeys(keys, items);
+  };
+}

package/dist/es2019/utils/createFileDataLoader.js

@@ -1,122 +1 @@
-import Dataloader from 'dataloader';
-import { getRandomTelemetryId } from '@atlaskit/media-common';
-export const MAX_BATCH_SIZE = 100;
-const isBatchLoadingErrorResult = result => {
-  return result.error instanceof Error;
-};
-const isResponseFileItem = fileItem => {
-  return 'details' in fileItem;
-};
-const makeCacheKey = (id, collection) => collection ? `${id}-${collection}` : id;
-export const getItemsFromKeys = (dataloaderKeys, fileItems) => {
-  const itemsByKey = fileItems.reduce((prev, fileItem) => {
-    const {
-      id,
-      collection
-    } = fileItem;
-    const key = makeCacheKey(id, collection);
-    if (isBatchLoadingErrorResult(fileItem)) {
-      prev[key] = fileItem.error;
-    } else if (isResponseFileItem(fileItem)) {
-      prev[key] = {
-        ...fileItem.details,
-        metadataTraceContext: fileItem.metadataTraceContext
-      };
-    } else {
-      prev[key] = {
-        id,
-        collection,
-        type: 'not-found',
-        metadataTraceContext: fileItem.metadataTraceContext
-      };
-    }
-    return prev;
-  }, {});
-  return dataloaderKeys.map(dataloaderKey => {
-    const {
-      id,
-      collectionName
-    } = dataloaderKey;
-    const key = makeCacheKey(id, collectionName);
-    return itemsByKey[key] || {
-      id,
-      type: 'not-found'
-    };
-  });
-};
-/**
- * Returns a function that, given Array<DataloaderKey>, resolves to an array of same length containing either DataloaderResult or Error.
- * Such contract is formalised by Dataloader 1.0, @see https://github.com/graphql/dataloader
- *
- * If an Error is resolved in the results, it must be at same position then their corresponding key:
- * - Dataloader will re-throw that Error when accessing/loading that particular key
- *
- * @param mediaStore instance of MediaStore
- */
-export function createBatchLoadingFunc(mediaStore) {
-  return async keys => {
-    const nonCollectionName = '__media-single-file-collection__';
-    const includeHashByCollection = keys.reduce((acc, key) => {
-      const collectionName = key.collectionName || nonCollectionName;
-      if (key.includeHashForDuplicateFiles) {
-        acc[collectionName] = key.includeHashForDuplicateFiles;
-      }
-      return acc;
-    }, {});
-    const fileIdsByCollection = keys.reduce((acc, key) => {
-      const collectionName = key.collectionName || nonCollectionName;
-      const fileIds = acc[collectionName] || [];
-
-      // de-duplicate ids in collection
-      if (fileIds.indexOf(key.id) === -1) {
-        fileIds.push(key.id);
-      }
-      acc[collectionName] = fileIds;
-      return acc;
-    }, {});
-    const items = [];
-    await Promise.all(Object.keys(fileIdsByCollection).map(async collectionNameKey => {
-      const metadataTraceContext = {
-        traceId: getRandomTelemetryId(),
-        spanId: getRandomTelemetryId()
-      };
-      const fileIds = fileIdsByCollection[collectionNameKey];
-      const includeHashForDuplicateFiles = includeHashByCollection[collectionNameKey];
-      const collectionName = collectionNameKey === nonCollectionName ? undefined : collectionNameKey;
-      try {
-        const response = await mediaStore.getItems(fileIds, collectionName, metadataTraceContext, includeHashForDuplicateFiles);
-        const itemsWithMetadataTraceContext = response.data.items.map(item => ({
-          ...item,
-          metadataTraceContext
-        }));
-        items.push(...itemsWithMetadataTraceContext);
-
-        // add EmptyResponseFileItem for each file ID not included in /items response
-        const itemsIds = itemsWithMetadataTraceContext.map(item => item.id);
-        const fileIdsNotFound = fileIds.filter(id => !itemsIds.includes(id));
-        fileIdsNotFound.forEach(fileId => {
-          items.push({
-            id: fileId,
-            collection: collectionName,
-            type: 'not-found',
-            metadataTraceContext
-          });
-        });
-      } catch (error) {
-        fileIds.forEach(fileId => {
-          items.push({
-            id: fileId,
-            collection: collectionName,
-            error: error
-          });
-        });
-      }
-    }));
-    return getItemsFromKeys(keys, items);
-  };
-}
-export function createFileDataloader(mediaStore) {
-  return new Dataloader(createBatchLoadingFunc(mediaStore), {
-    maxBatchSize: MAX_BATCH_SIZE
-  });
-}
+export const MAX_BATCH_SIZE = 100;

package/dist/es2019/utils/createFileDataloader-2.js

@@ -0,0 +1,8 @@
+import Dataloader from 'dataloader';
+import { createBatchLoadingFunc } from './createBatchLoadingFunc';
+import { MAX_BATCH_SIZE } from './createFileDataLoader';
+export function createFileDataloader(mediaStore) {
+  return new Dataloader(createBatchLoadingFunc(mediaStore), {
+    maxBatchSize: MAX_BATCH_SIZE
+  });
+}

package/dist/es2019/utils/getAttrsFromUrl.js

@@ -0,0 +1,35 @@
+const getNumberFromParams = (params, name) => {
+  const value = params.get(name);
+  return typeof value === 'string' && !isNaN(parseInt(value)) ? parseInt(value) : undefined;
+};
+const getStringFromParams = (params, name) => {
+  const value = params.get(name);
+  if (!value) {
+    return;
+  }
+  return decodeURIComponent(value);
+};
+export const getAttrsFromUrl = blobUrl => {
+  const url = new URL(blobUrl);
+  const hash = url.hash.replace('#', '');
+  const params = new URLSearchParams(hash);
+  const id = params.get('id');
+  const contextId = params.get('contextId');
+  const clientId = params.get('clientId');
+  // check if we have the required params (clientId is optional for backwards compatibility)
+  if (!id || !contextId) {
+    return;
+  }
+  return {
+    id,
+    contextId,
+    clientId: clientId || undefined,
+    collection: getStringFromParams(params, 'collection'),
+    alt: getStringFromParams(params, 'alt'),
+    height: getNumberFromParams(params, 'height'),
+    width: getNumberFromParams(params, 'width'),
+    size: getNumberFromParams(params, 'size'),
+    name: getStringFromParams(params, 'name'),
+    mimeType: getStringFromParams(params, 'mimeType')
+  };
+};

package/dist/es2019/utils/getItemsFromKeys.js

@@ -0,0 +1,43 @@
+const isBatchLoadingErrorResult = result => {
+  return result.error instanceof Error;
+};
+const isResponseFileItem = fileItem => {
+  return 'details' in fileItem;
+};
+const makeCacheKey = (id, collection) => collection ? `${id}-${collection}` : id;
+export const getItemsFromKeys = (dataloaderKeys, fileItems) => {
+  const itemsByKey = fileItems.reduce((prev, fileItem) => {
+    const {
+      id,
+      collection
+    } = fileItem;
+    const key = makeCacheKey(id, collection);
+    if (isBatchLoadingErrorResult(fileItem)) {
+      prev[key] = fileItem.error;
+    } else if (isResponseFileItem(fileItem)) {
+      prev[key] = {
+        ...fileItem.details,
+        metadataTraceContext: fileItem.metadataTraceContext
+      };
+    } else {
+      prev[key] = {
+        id,
+        collection,
+        type: 'not-found',
+        metadataTraceContext: fileItem.metadataTraceContext
+      };
+    }
+    return prev;
+  }, {});
+  return dataloaderKeys.map(dataloaderKey => {
+    const {
+      id,
+      collectionName
+    } = dataloaderKey;
+    const key = makeCacheKey(id, collectionName);
+    return itemsByKey[key] || {
+      id,
+      type: 'not-found'
+    };
+  });
+};

package/dist/es2019/utils/isCDNEnabled.js

@@ -0,0 +1,9 @@
+import { isGoogleCloudPlatform } from '@atlaskit/atlassian-context/cloud-provider';
+import { isIsolatedCloud } from '@atlaskit/atlassian-context/is-isolated-cloud';
+import { isGCPtenant as isGCPtenantInStaging } from '@atlaskit/media-common/mediaEnvUtils';
+import { fg } from '@atlaskit/platform-feature-flags';
+import { isCommercial } from './isCommercial';
+import { isPathBasedEnabled } from './isPathBasedEnabled';
+export function isCDNEnabled() {
+  return isCommercial() && !isIsolatedCloud() && !(isGoogleCloudPlatform() || isGCPtenantInStaging()) && fg('platform_media_cdn_delivery') && !isPathBasedEnabled();
+}

package/dist/es2019/utils/isMediaBlobUrl.js

@@ -0,0 +1,4 @@
+import { mediaBlobUrlIdentifier } from './url';
+export const isMediaBlobUrl = url => {
+  return url.indexOf(`${mediaBlobUrlIdentifier}=true`) > -1;
+};

package/dist/es2019/utils/isPathBasedEnabled.js

@@ -0,0 +1,7 @@
+import { fg } from '@atlaskit/platform-feature-flags';
+import getDocument from './getDocument';
+export function isPathBasedEnabled() {
+  var _getDocument, _getDocument$location;
+  const isLocalhost = ((_getDocument = getDocument()) === null || _getDocument === void 0 ? void 0 : (_getDocument$location = _getDocument.location) === null || _getDocument$location === void 0 ? void 0 : _getDocument$location.hostname) === 'localhost';
+  return fg('platform_media_path_based_route') && !isLocalhost;
+}

package/dist/es2019/utils/mapRetryUrlToPathBasedUrl.js

@@ -0,0 +1,17 @@
+import getDocument from './getDocument';
+import { mediaApiPathPrefix } from './pathBasedUrl';
+export function mapRetryUrlToPathBasedUrl(url) {
+  var _getDocument$location, _getDocument;
+  const parsedUrl = new URL(url);
+  parsedUrl.host = (_getDocument$location = (_getDocument = getDocument()) === null || _getDocument === void 0 ? void 0 : _getDocument.location.host) !== null && _getDocument$location !== void 0 ? _getDocument$location : '';
+
+  // remove CDN from the URL for retry if it exists
+  const pathname = parsedUrl.pathname;
+  if (pathname.endsWith('/cdn')) {
+    parsedUrl.pathname = pathname.replace('/cdn', '');
+  }
+  if (!parsedUrl.pathname.startsWith(mediaApiPathPrefix)) {
+    parsedUrl.pathname = `${mediaApiPathPrefix}${parsedUrl.pathname}`;
+  }
+  return parsedUrl;
+}

package/dist/es2019/utils/mapToMediaCdnUrl.js

@@ -0,0 +1,32 @@
+import { isGoogleCloudPlatform } from '@atlaskit/atlassian-context/cloud-provider';
+import { isGCPtenant as isGCPtenantInStaging } from '@atlaskit/media-common/mediaEnvUtils';
+import { fg } from '@atlaskit/platform-feature-flags';
+import { isCDNEnabled } from './isCDNEnabled';
+import { MEDIA_CDN_MAP, MEDIA_TOKEN_LENGTH_LIMIT } from './mediaCdn';
+export function mapToMediaCdnUrl(url, token) {
+  var _token$length;
+  const tokenLength = (_token$length = token === null || token === void 0 ? void 0 : token.length) !== null && _token$length !== void 0 ? _token$length : 0;
+  if (!isCDNEnabled() || tokenLength > MEDIA_TOKEN_LENGTH_LIMIT) {
+    return url;
+  }
+  const isGcpTenant = isGoogleCloudPlatform() || isGCPtenantInStaging();
+  // eslint-disable-next-line @atlaskit/platform/no-preconditioning
+  if (!isGcpTenant && fg('platform_media_cdn_delivery') && fg('platform_media_cdn_single_host')) {
+    try {
+      const parsedUrl = new URL(url);
+      const cdnHost = MEDIA_CDN_MAP[parsedUrl.host];
+
+      // If no mapping is found, return the original URL
+      if (!cdnHost) {
+        return url;
+      }
+
+      // Replace the host with the CDN host in the original URL
+      parsedUrl.host = cdnHost;
+      return parsedUrl.toString();
+    } catch (error) {
+      return url;
+    }
+  }
+  return url;
+}

package/dist/es2019/utils/mapToPathBasedUrl.js

@@ -0,0 +1,25 @@
+import getDocument from './getDocument';
+import { isPathBasedEnabled } from './isPathBasedEnabled';
+import { mediaApiPathPrefix } from './pathBasedUrl';
+function getRelativeUrl(absoluteUrl) {
+  const url = new URL(absoluteUrl);
+  return `${url.pathname}${url.search}${url.hash}`;
+}
+export function mapToPathBasedUrl(url) {
+  if (isPathBasedEnabled()) {
+    var _getDocument;
+    const parsedUrl = new URL(url);
+    if (!parsedUrl.pathname.startsWith(mediaApiPathPrefix)) {
+      parsedUrl.pathname = `${mediaApiPathPrefix}${parsedUrl.pathname}`;
+    }
+    const location = (_getDocument = getDocument()) === null || _getDocument === void 0 ? void 0 : _getDocument.location;
+
+    // in this case we are most likely in SSR / a non browser environment so just return a relative URL
+    if (!location) {
+      return getRelativeUrl(parsedUrl.toString());
+    }
+    parsedUrl.host = location.host;
+    return parsedUrl.toString();
+  }
+  return url;
+}

package/dist/es2019/utils/mediaCdn.js

@@ -1,9 +1,3 @@
-import { fg } from '@atlaskit/platform-feature-flags';
-import { isCommercial } from './isCommercial';
-import { isIsolatedCloud } from '@atlaskit/atlassian-context/is-isolated-cloud';
-import { isGoogleCloudPlatform } from '@atlaskit/atlassian-context/cloud-provider';
-import { isGCPtenant as isGCPtenantInStaging } from '@atlaskit/media-common/mediaEnvUtils';
-import { isPathBasedEnabled } from './pathBasedUrl';
 export const MEDIA_CDN_MAP = {
   'api.media.atlassian.com': 'media-cdn.atlassian.com',
   'media.staging.atl-paas.net': 'media-cdn.stg.atlassian.com'
@@ -12,34 +6,4 @@ export const MEDIA_CDN_MAP = {
 // Cloudfront has a hard limit of 8,192 bytes
 // https://docs.aws.amazon.com/AmazonCloudFront/latest/DeveloperGuide/cloudfront-limits.html
 // Assuming other parts of the URL make up a max of ~1000 (in reality it's lower), the token can be ~7000
-const MEDIA_TOKEN_LENGTH_LIMIT = 7000;
-export function isCDNEnabled() {
-  return isCommercial() && !isIsolatedCloud() && !(isGoogleCloudPlatform() || isGCPtenantInStaging()) && fg('platform_media_cdn_delivery') && !isPathBasedEnabled();
-}
-export function mapToMediaCdnUrl(url, token) {
-  var _token$length;
-  const tokenLength = (_token$length = token === null || token === void 0 ? void 0 : token.length) !== null && _token$length !== void 0 ? _token$length : 0;
-  if (!isCDNEnabled() || tokenLength > MEDIA_TOKEN_LENGTH_LIMIT) {
-    return url;
-  }
-  const isGcpTenant = isGoogleCloudPlatform() || isGCPtenantInStaging();
-  // eslint-disable-next-line @atlaskit/platform/no-preconditioning
-  if (!isGcpTenant && fg('platform_media_cdn_delivery') && fg('platform_media_cdn_single_host')) {
-    try {
-      const parsedUrl = new URL(url);
-      const cdnHost = MEDIA_CDN_MAP[parsedUrl.host];
-
-      // If no mapping is found, return the original URL
-      if (!cdnHost) {
-        return url;
-      }
-
-      // Replace the host with the CDN host in the original URL
-      parsedUrl.host = cdnHost;
-      return parsedUrl.toString();
-    } catch (error) {
-      return url;
-    }
-  }
-  return url;
-}
+export const MEDIA_TOKEN_LENGTH_LIMIT = 7000;

package/dist/es2019/utils/mediaSubscribable/createMediaSubscribable.js

@@ -0,0 +1,5 @@
+import { createMediaSubject } from '../createMediaSubject';
+import { fromObservable } from './fromObservable';
+export function createMediaSubscribable(item) {
+  return fromObservable(createMediaSubject(item));
+}

package/dist/es2019/utils/mediaSubscribable/fromObservable.js

@@ -1,4 +1,5 @@
-import { createMediaSubject } from '../createMediaSubject';
+/* eslint-disable @repo/internal/deprecations/deprecation-ticket-required -- VOLTC-139 tracks removal of these deprecated re-export shims. */
+
 export function fromObservable(observable) {
   return {
     subscribe: observer => {
@@ -14,6 +15,8 @@ export function fromObservable(observable) {
     }
   };
 }
-export function createMediaSubscribable(item) {
-  return fromObservable(createMediaSubject(item));
-}
+
+/**
+ * @deprecated Use `import { createMediaSubscribable } from '@atlaskit/media-client'` instead.
+ */
+export { createMediaSubscribable } from './createMediaSubscribable';

package/dist/es2019/utils/mobileUpload/{error.js → MobileUploadError.js}

@@ -1,4 +1,4 @@
-import { BaseMediaClientError } from '../../models/errors';
+import { BaseMediaClientError } from '../../models/errors/BaseMediaClientError';
 export class MobileUploadError extends BaseMediaClientError {
   // Legacy Attribute. Should be removed
 
@@ -29,7 +29,4 @@ export class MobileUploadError extends BaseMediaClientError {
       }
     };
   }
-}
-export function isMobileUploadError(err) {
-  return err instanceof MobileUploadError;
 }

package/dist/es2019/utils/mobileUpload/{helpers.js → createMobileDownloadFileStream.js}

@@ -1,17 +1,9 @@
-import { ReplaySubject } from 'rxjs/ReplaySubject';
-import { from } from 'rxjs/observable/from';
-import { map } from 'rxjs/operators/map';
-import { mapMediaItemToFileState } from '../../models/file-state';
+import { isNotFoundMediaItemDetails } from '../../models/is-not-found-media-item-details';
+import { mapMediaItemToFileState } from '../../models/map-media-item-to-file-state';
 import { createMediaSubject } from '../createMediaSubject';
 import { isEmptyFile } from '../detectEmptyFile';
 import { PollingFunction } from '../polling';
-import { MobileUploadError } from './error';
-import { isNotFoundMediaItemDetails } from '../../models/media';
-export const createMobileFileStateSubject = service => {
-  const subject = new ReplaySubject(1);
-  from(service.start()).pipe(map(state => state.context.currentFileState)).subscribe(subject);
-  return subject;
-};
+import { MobileUploadError } from './MobileUploadError';
 export const createMobileDownloadFileStream = (dataloader, id, collectionName, occurrenceKey) => {
   const subject = createMediaSubject();
   const poll = new PollingFunction();

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

@@ -0,0 +1,8 @@
+import { from } from 'rxjs/observable/from';
+import { map } from 'rxjs/operators/map';
+import { ReplaySubject } from 'rxjs/ReplaySubject';
+export const createMobileFileStateSubject = service => {
+  const subject = new ReplaySubject(1);
+  from(service.start()).pipe(map(state => state.context.currentFileState)).subscribe(subject);
+  return subject;
+};

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

@@ -0,0 +1,4 @@
+import { MobileUploadError } from './MobileUploadError';
+export function isMobileUploadError(err) {
+  return err instanceof MobileUploadError;
+}

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

@@ -0,0 +1,4 @@
+import { interpret } from 'xstate';
+export function createMobileUploadService(machine) {
+  return interpret(machine);
+}

package/dist/es2019/utils/mobileUpload/stateMachine/{index.js → createMobileUploadStateMachine.js}

@@ -1,13 +1,13 @@
 import { map } from 'rxjs/operators/map';
-import { createMachine, interpret } from 'xstate';
-import { isProcessingFileState } from '../../../models/file-state';
+import { createMachine } from 'xstate';
+import { isProcessingFileState } from '../../../models/is-processing-file-state';
 import { shouldFetchRemoteFileStates } from '../../shouldFetchRemoteFileStates';
-import { createMobileDownloadFileStream } from '../helpers';
-import { machineUploadingState } from './states/uploading';
-import { machineProcessingState } from './states/processing';
+import { createMobileDownloadFileStream } from '../createMobileDownloadFileStream';
+import { machineErrorState } from './states/error';
 import { machineProcessedState } from './states/processed';
+import { machineProcessingState } from './states/processing';
 import { machineProcessingFailedState } from './states/processingFailed';
-import { machineErrorState } from './states/error';
+import { machineUploadingState } from './states/uploading';
 export const createMobileUploadStateMachine = (dataloader, initialState, collectionName) => createMachine({
   // Initial state
   initial: initialState.status,
@@ -44,7 +44,4 @@ export const createMobileUploadStateMachine = (dataloader, initialState, collect
       fileState
     })))
   }
-});
-export function createMobileUploadService(machine) {
-  return interpret(machine);
-}
+});

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

@@ -1,5 +1,5 @@
 import { assign } from 'xstate';
-import { isUploadingFileState } from '../../../../models/file-state';
+import { isUploadingFileState } from '../../../../models/is-uploading-file-state';
 export const machineUploadingState = {
   // Events
   on: {

package/dist/es2019/utils/objectToQueryString.js

@@ -0,0 +1,9 @@
+export const objectToQueryString = json => {
+  return Object.keys(json).filter(attrName => typeof json[attrName] !== 'undefined' && json[attrName] !== null).map(key => {
+    const value = json[key];
+    if (typeof value === 'undefined' || value === null) {
+      return;
+    }
+    return `${encodeURIComponent(key)}=${encodeURIComponent(value.toString())}`;
+  }).join('&');
+};