@atlaskit/media-client 25.0.3 → 25.1.0

package/dist/cjs/test-helpers/index.js

@@ -64,6 +64,42 @@ Object.defineProperty(exports, "collectionNames", {
     return _collectionNames.collectionNames;
   }
 });
+Object.defineProperty(exports, "copy", {
+  enumerable: true,
+  get: function get() {
+    return _MockedMediaApi.copy;
+  }
+});
+Object.defineProperty(exports, "createEmptyFileItem", {
+  enumerable: true,
+  get: function get() {
+    return _MockedMediaApi.createEmptyFileItem;
+  }
+});
+Object.defineProperty(exports, "createErrorFileState", {
+  enumerable: true,
+  get: function get() {
+    return _MockedMediaApi.createErrorFileState;
+  }
+});
+Object.defineProperty(exports, "createFileState", {
+  enumerable: true,
+  get: function get() {
+    return _MockedMediaApi.createFileState;
+  }
+});
+Object.defineProperty(exports, "createMockedMediaApi", {
+  enumerable: true,
+  get: function get() {
+    return _MockedMediaApi.createMockedMediaApi;
+  }
+});
+Object.defineProperty(exports, "createProcessingFileItem", {
+  enumerable: true,
+  get: function get() {
+    return _MockedMediaApi.createProcessingFileItem;
+  }
+});
 Object.defineProperty(exports, "createStorybookMediaClient", {
   enumerable: true,
   get: function get() {
@@ -88,6 +124,12 @@ Object.defineProperty(exports, "createUploadMediaClientConfig", {
     return _mediaClientProvider.createUploadMediaClientConfig;
   }
 });
+Object.defineProperty(exports, "createUploadingFileState", {
+  enumerable: true,
+  get: function get() {
+    return _MockedMediaApi.createUploadingFileState;
+  }
+});
 Object.defineProperty(exports, "defaultBaseUrl", {
   enumerable: true,
   get: function get() {
@@ -202,6 +244,12 @@ Object.defineProperty(exports, "genericFileId", {
     return _exampleMediaItems.genericFileId;
   }
 });
+Object.defineProperty(exports, "getIdentifier", {
+  enumerable: true,
+  get: function get() {
+    return _MockedMediaApi.getIdentifier;
+  }
+});
 Object.defineProperty(exports, "gifFileId", {
   enumerable: true,
   get: function get() {
@@ -370,4 +418,5 @@ var _collectionNames = require("./collectionNames");
 var _exampleMediaItems = require("./exampleMediaItems");
 var _mediaPickerAuthProvider = require("./mediaPickerAuthProvider");
 var _fakeMediaClient = require("./fakeMediaClient");
+var _MockedMediaApi = require("./MockedMediaApi");
 var authProviderBaseURL = exports.authProviderBaseURL = 'https://media.dev.atl-paas.net';

package/dist/es2019/test-helpers/MockedMediaApi/MockedMediaApi.js

@@ -0,0 +1,164 @@
+import { getMediaFile, normaliseInput } from './helpers';
+const getMediaApi = ({
+  getFileItem
+}) => ({
+  // --------------------------------------------------------
+  // UPLOAD ENDPOINTS - None is supported
+  // --------------------------------------------------------
+
+  touchFiles: async ({
+    descriptors
+  }) => {
+    throw new Error('500 - MockedMediaApi.touchFiles: method not implemented');
+  },
+  probeChunks: async (...args) => {
+    throw new Error('500 - MockedMediaApi.probeChunks: method not implemented');
+  },
+  uploadChunk: async (_etag, _blob, uploadId) => {
+    throw new Error('500 - MockedMediaApi.uploadChunk: method not implemented');
+  },
+  appendChunksToUpload: async () => {
+    throw new Error('500 - MockedMediaApi.appendChunksToUpload: method not implemented');
+  },
+  createFileFromUpload: async ({
+    uploadId
+  }, {
+    collection
+  }) => {
+    throw new Error('500 - MockedMediaApi.createFileFromUpload: method not implemented');
+  },
+  // Used by Media Picker as a fallback for conflicted file Ids
+  createUpload: async () => {
+    throw new Error('500 - MockedMediaApi.createUpload: method not implemented');
+  },
+  // For File size limits
+  getRejectedResponseFromDescriptor: () => {
+    throw new Error('500 - MockedMediaApi.getRejectedResponseFromDescriptor: method not implemented');
+  },
+  // --------------------------------------------------------
+  // METADATA ENDPOINTS
+  // --------------------------------------------------------
+
+  getFile: async fileId => {
+    const fileItem = getFileItem(fileId);
+    if (!fileItem) {
+      throw new Error('404 - MockedMediaApi.getFile: file not found');
+    }
+    return {
+      data: getMediaFile(fileItem)
+    };
+  },
+  getItems: async ids => {
+    const items = ids.map(id => getFileItem(id)).filter(fileState => !!fileState);
+    return {
+      data: {
+        items
+      }
+    };
+  },
+  // TODO
+  getImageMetadata: async () => {
+    throw new Error('500 - MockedMediaApi.getImageMetadata: method not implemented');
+  },
+  // --------------------------------------------------------
+  // URL ENDPOINTS
+  // --------------------------------------------------------
+
+  // TODO
+  getFileImageURL: async () => {
+    throw new Error('500 - MockedMediaApi.getFileImageURL: method not implemented');
+  },
+  // TODO
+  getFileImageURLSync: () => {
+    throw new Error('500 - MockedMediaApi.getFileImageURLSync: method not implemented');
+  },
+  getFileBinaryURL: async id => {
+    const fileItem = getFileItem(id);
+    if (!fileItem) {
+      throw new Error('404 - MockedMediaApi.getFileBinaryURL: file not found');
+    }
+    if (fileItem.details.size === 0) {
+      // TODO veryify if this is the correct answer for an uploading file
+      throw new Error('404 - MockedMediaApi.getFileBinaryURL: file is empty');
+    }
+    return `/file/${id}/binary`;
+  },
+  getArtifactURL: async (artifacts, artifactName) => {
+    var _artifacts$artifactNa;
+    const artifactUrl = (_artifacts$artifactNa = artifacts[artifactName]) === null || _artifacts$artifactNa === void 0 ? void 0 : _artifacts$artifactNa.url;
+    if (!artifactUrl) {
+      throw new Error(`404 - MockedMediaApi.getArtifactURL: artifact ${artifactName} not found`);
+    }
+    return artifactUrl;
+  },
+  // --------------------------------------------------------
+  // BINARY ENDPOINTS
+  // --------------------------------------------------------
+  getImage: async fileId => {
+    const fileItem = getFileItem(fileId);
+    if (!fileItem) {
+      throw new Error('404 - MockedMediaApi.getImage: file not found');
+    }
+    if (!fileItem.details.representations.image) {
+      throw new Error('404 - MockedMediaApi.getImage: image not found');
+    }
+
+    // Empty Blob. Might have to change for a real one if TLR loads the image
+    return new Blob();
+  },
+  // --------------------------------------------------------
+  // OTHER ENDPOINTS
+  // --------------------------------------------------------
+
+  // TODO
+  copyFileWithToken: async body => {
+    const fileId = body.sourceFile.id;
+    const fileItem = getFileItem(fileId);
+    if (!fileItem) {
+      throw new Error('404 - MockedMediaApi.copyFileWithToken: file not found');
+    }
+    return {
+      data: getMediaFile(fileItem)
+    };
+  },
+  // TODO
+  removeCollectionFile: async () => {},
+  // --------------------------------------------------------
+  // OTHER ENDPOINTS
+  // --------------------------------------------------------
+  request: async () => new Response(),
+  resolveAuth: async () => ({
+    asapIssuer: '',
+    token: '',
+    baseUrl: ''
+  }),
+  resolveInitialAuth: () => ({
+    asapIssuer: '',
+    token: '',
+    baseUrl: ''
+  })
+});
+
+/**
+ * Mocked Media API
+ */
+export const createMockedMediaApi = initialFileItems => {
+  const storedFileItems = new Map();
+  const getFileItem = fileId => storedFileItems.get(fileId);
+  const setFileItems = fileItems => {
+    const normalised = normaliseInput(fileItems);
+    normalised.forEach(fileItem => storedFileItems.set(fileItem.id, fileItem));
+  };
+  if (initialFileItems) {
+    setFileItems(initialFileItems);
+  }
+  const mediaApi = getMediaApi({
+    setFileItems,
+    getFileItem
+  });
+  return {
+    setFileItems,
+    getFileItem,
+    mediaApi
+  };
+};

package/dist/es2019/test-helpers/MockedMediaApi/helpers.js

@@ -0,0 +1,166 @@
+import uuid from 'uuid/v4';
+// --------------------------------------------------------
+// Factory Utils
+// --------------------------------------------------------
+export const normaliseInput = input => !input ? [] : input instanceof Array ? input : [input];
+
+// --------------------------------------------------------
+// Utils for the main class
+// --------------------------------------------------------
+
+export const getMediaFile = fileItem => ({
+  id: fileItem.id,
+  ...fileItem.details
+});
+
+// --------------------------------------------------------
+// Utils for creating file descriptors for tests
+// --------------------------------------------------------
+
+export const createEmptyFileItem = (id, collection) => {
+  const emptyFileItem = {
+    type: 'file',
+    id,
+    details: {
+      mediaType: 'unknown',
+      mimeType: 'binary/octet-stream',
+      name: '',
+      size: 0,
+      processingStatus: 'pending',
+      artifacts: {},
+      representations: {},
+      createdAt: 1699488941974
+    }
+  };
+  if (collection) {
+    emptyFileItem.collection = collection;
+  }
+  return emptyFileItem;
+};
+
+/**
+ * Simulates the processing of the file by updating the processing status of the artifacts by a percentage
+ * Percent must be between 0 and 1
+ */
+export const createProcessingFileItem = (fileItem, percent) => {
+  if (percent < 0 || percent > 1) {
+    throw new Error('Error createProcessingFileItem: percent must be between 0 and 1');
+  }
+
+  /**
+   * This behaviour has to be confirmed
+   * Artifacts show up immediately after processed or they have a
+   * "processing time"?
+   */
+
+  if (percent === 1) {
+    return fileItem;
+  }
+
+  // No artifacts for 0% processing
+  if (percent === 0) {
+    return {
+      ...fileItem,
+      details: {
+        ...fileItem.details,
+        processingStatus: 'pending',
+        artifacts: {},
+        // The preview will only be ready at 100% -> TODO verify against backend
+        representations: {}
+      }
+    };
+  }
+  const artifactsKeys = Object.keys(fileItem.details.artifacts);
+  const artifactsEntries = Object.entries({
+    ...fileItem.details.artifacts // Spreading to make TS happy
+  });
+
+  // Get a % of the total artifacts to be set as processed
+  const processedArtifactKeys = artifactsKeys.slice(0, Math.ceil(artifactsKeys.length * percent));
+  const processedArtifactEntries = artifactsEntries.map(([key, artifact]) => [key, {
+    ...artifact,
+    processingStatus: processedArtifactKeys.includes(key) ? 'succeeded' : 'pending'
+  }]);
+  const artifactsProcessingPercent = Object.fromEntries(processedArtifactEntries);
+  return {
+    ...fileItem,
+    details: {
+      ...fileItem.details,
+      processingStatus: 'pending',
+      artifacts: artifactsProcessingPercent,
+      // The preview will only be ready at 100% -> TODO verify against backend
+      representations: {}
+    }
+  };
+};
+
+/**
+ * Makes a copy of the provided file item with a random file id
+ * */
+export const copy = fileItem => JSON.parse(JSON.stringify(fileItem).replace(new RegExp(fileItem.id, 'g'), uuid()));
+/**
+ * Extracts the file identifier from the provided file item
+ */
+export const getIdentifier = fileItem => ({
+  mediaItemType: 'file',
+  id: fileItem.id,
+  collectionName: fileItem.collection
+});
+export const createFileState = ({
+  id,
+  details: {
+    name,
+    size,
+    mediaType,
+    mimeType,
+    createdAt,
+    processingStatus,
+    artifacts,
+    representations
+  }
+}) => ({
+  status: processingStatus === 'succeeded' ? 'processed' : 'processing',
+  id,
+  name,
+  size,
+  mediaType,
+  mimeType,
+  createdAt,
+  artifacts,
+  representations
+});
+export const createUploadingFileState = ({
+  id,
+  details: {
+    name,
+    size,
+    mediaType,
+    mimeType,
+    createdAt
+  }
+}, progress) => ({
+  status: 'uploading',
+  progress,
+  id,
+  name,
+  size,
+  mediaType,
+  mimeType,
+  createdAt,
+  preview: {
+    value: new Blob(['some-content'], {
+      type: mimeType
+    })
+  }
+});
+export const createErrorFileState = ({
+  id
+}) => ({
+  status: 'error',
+  id,
+  reason: 'a random error',
+  message: 'a random error message',
+  details: {
+    some: 'mocked error detail'
+  }
+});

package/dist/es2019/test-helpers/MockedMediaApi/index.js

@@ -0,0 +1,2 @@
+export { createMockedMediaApi } from './MockedMediaApi';
+export { copy, getIdentifier, createEmptyFileItem, createUploadingFileState, createErrorFileState, createFileState, createProcessingFileItem } from './helpers';

package/dist/es2019/test-helpers/index.js

@@ -4,4 +4,5 @@ export { collectionNames, defaultCollectionName, defaultMediaPickerCollectionNam
 export { animatedFileId, archiveFileId, atlassianLogoUrl, audioFileDetails, audioFileId, audioNoCoverFileId, bigDocFileId, docFileDetails, docFileId, emptyImageFileId, errorFileId, externalImageIdentifier, externalSmallImageIdentifier, externaBrokenlIdentifier, genericDataURI, genericFileDetails, genericFileId, gifFileId, imageFileDetails, imageFileId, largeImageFileId, largePdfFileId, noMetadataFileId, passwordProtectedPdfFileId, smallImageFileId, unknownFileDetails, unknownFileId, verticalImageFileId, videoFileDetails, videoFileId, videoHorizontalFileId, videoLargeFileId, videoProcessingFailedId, videoSquareFileId, wideImageFileId, zipFileId, zipFileWithNestedFolderId, zipItemLargeInnerFileId, zipItemMultipleFoldersAtRootId, zipJiraArchiveFileId, zipEncryptedFileId, codeFileId, emailFileId, emailUnsupportedFileId, vrVideoDetails } from './exampleMediaItems';
 export const authProviderBaseURL = 'https://media.dev.atl-paas.net';
 export { mediaPickerAuthProvider, defaultMediaPickerAuthProvider } from './mediaPickerAuthProvider';
-export { fakeMediaClient } from './fakeMediaClient';
+export { fakeMediaClient } from './fakeMediaClient';
+export { createMockedMediaApi, copy, getIdentifier, createProcessingFileItem, createEmptyFileItem, createUploadingFileState, createFileState, createErrorFileState } from './MockedMediaApi';