@atlaskit/media-client 26.2.3 → 27.0.0

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

@@ -1,63 +0,0 @@
-import { MediaClient } from '../';
-import { asMock, getJest } from '@atlaskit/media-common/test-helpers';
-const jest = getJest();
-export const getDefaultMediaClientConfig = () => ({
-  authProvider: jest.fn().mockReturnValue(Promise.resolve({
-    clientId: 'some-client-id',
-    token: 'some-token',
-    baseUrl: 'some-service-host'
-  }))
-});
-export const fakeMediaClient = (config = getDefaultMediaClientConfig()) => {
-  if (jest && jest.genMockFromModule) {
-    const {
-      MediaClient: MockMediaClient,
-      FileFetcherImpl,
-      MediaStore: MockMediaStore,
-      StargateClient
-    } = jest.genMockFromModule('@atlaskit/media-client');
-    const mediaClient = new MockMediaClient();
-    const fileFetcher = new FileFetcherImpl();
-    const mockMediaStore = new MockMediaStore({
-      authProvider: config.authProvider
-    });
-    const stargateClient = new StargateClient();
-    mediaClient.file = fileFetcher;
-    mediaClient.stargate = stargateClient;
-    mediaClient.config = config; // <- deprecated
-    mediaClient.mediaClientConfig = config;
-    mediaClient.mediaStore = mockMediaStore;
-    mediaClient.mediaStore.getItems = jest.fn().mockResolvedValue({
-      data: {
-        items: []
-      }
-    });
-    asMock(mediaClient.getImageUrl).mockResolvedValue('some-image-url');
-    asMock(mediaClient.getImageUrlSync).mockReturnValue('some-image-url');
-    asMock(mediaClient.getImage).mockImplementation(mockMediaStore.getImage);
-    asMock(mediaClient.file.copyFile).mockReturnValue({
-      id: 'copied-file-id'
-    });
-    asMock(mediaClient.file.getCurrentState).mockReturnValue(Promise.resolve({
-      id: 'file-id',
-      status: 'processed',
-      mediaType: 'image',
-      name: 'file_name'
-    }));
-    asMock(mediaClient.file.getFileState).mockImplementation(() => ({
-      subscribe: jest.fn()
-    }));
-    asMock(mediaClient.stargate.fetchToken).mockImplementation(() => Promise.resolve({
-      data: {
-        clientId: 'some-client-id-from-smart-edge',
-        token: 'some-token-from-smart-edge',
-        baseUrl: 'some-base-url-from-smart-edge',
-        expiresIn: 34000,
-        iat: new Date().getTime() / 1000
-      }
-    }));
-    return mediaClient;
-  } else {
-    return new MediaClient(config);
-  }
-};

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

@@ -1,8 +0,0 @@
-export { StoryBookAuthProvider } from './authProvider';
-export { createStorybookMediaClient, createStorybookMediaClientConfig, createUploadMediaClient, createUploadMediaClientConfig, defaultBaseUrl, defaultParams } from './mediaClientProvider';
-export { collectionNames, defaultCollectionName, defaultMediaPickerCollectionName, fileCollectionName, onlyAnimatedGifsCollectionName } from './collectionNames';
-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 { createMockedMediaApi, copy, getIdentifier, createProcessingFileItem, createEmptyFileItem, createUploadingFileState, createFileState, createErrorFileState } from './MockedMediaApi';

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

@@ -1,42 +0,0 @@
-import { MediaClient } from '../';
-import { StoryBookAuthProvider } from './authProvider';
-import { collectionNames } from './collectionNames';
-import { mediaPickerAuthProvider } from './mediaPickerAuthProvider';
-export const defaultBaseUrl = 'https://media.dev.atl-paas.net';
-export const defaultParams = {
-  clientId: '5a9812fc-d029-4a39-8a46-d3cc36eed7ab',
-  asapIssuer: 'micros/media-playground',
-  baseUrl: defaultBaseUrl
-};
-const defaultAuthParameter = {
-  authType: 'client'
-};
-
-/**
- * Creates and returns `MediaClient` (from `media-client`) based on the data provided in parameter object.
- *
- * @param {AuthParameter} authParameter specifies serviceName and whatever auth should be done with clientId or asapIssuer
- * @returns {Context}
- */
-export const createStorybookMediaClient = (authParameter = defaultAuthParameter) => {
-  return new MediaClient(createStorybookMediaClientConfig(authParameter));
-};
-export const createStorybookMediaClientConfig = (authParameter = defaultAuthParameter) => {
-  const scopes = {
-    'urn:filestore:file:*': ['read'],
-    'urn:filestore:chunk:*': ['read']
-  };
-  collectionNames.forEach(c => {
-    scopes[`urn:filestore:collection:${c}`] = ['read', 'update'];
-  });
-  const isAsapEnvironment = authParameter.authType === 'asap';
-  const authProvider = StoryBookAuthProvider.create(isAsapEnvironment, scopes);
-  return {
-    authProvider
-  };
-};
-export const createUploadMediaClient = () => new MediaClient(createUploadMediaClientConfig());
-export const createUploadMediaClientConfig = (stargateBaseUrl, env) => ({
-  authProvider: mediaPickerAuthProvider('asap', env),
-  stargateBaseUrl
-});

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

@@ -1,56 +0,0 @@
-import { defaultCollectionName } from './collectionNames';
-export const authProviderBaseURL = 'https://media.dev.atl-paas.net';
-const cachedAuths = {};
-const accessUrns = {
-  MediaServicesSample: {
-    'urn:filestore:collection:MediaServicesSample': ['read', 'insert'],
-    'urn:filestore:chunk:*': ['create', 'read'],
-    'urn:filestore:upload': ['create'],
-    'urn:filestore:upload:*': ['read', 'update'],
-    'urn:filestore:file': ['create'],
-    'urn:filestore:file:*': ['read', 'update']
-  },
-  'mediapicker-test': {
-    'urn:filestore:collection': ['create'],
-    'urn:filestore:collection:mediapicker-test': ['read', 'insert'],
-    'urn:filestore:chunk:*': ['create', 'read'],
-    'urn:filestore:upload': ['create'],
-    'urn:filestore:upload:*': ['read', 'update'],
-    'urn:filestore:file': ['create'],
-    'urn:filestore:file:*': ['read', 'update']
-  }
-};
-const requestAuthProvider = async (authEnvironment, collectionName, env = 'dev') => {
-  const url = `https://media-playground.${env}.atl-paas.net/token/tenant?environment=${authEnvironment}`;
-  const body = JSON.stringify({
-    access: accessUrns[collectionName] || {}
-  });
-  const headers = new Headers();
-  headers.append('Content-Type', 'application/json; charset=utf-8');
-  headers.append('Accept', 'text/plain, */*; q=0.01');
-  const response = await fetch(url, {
-    method: 'POST',
-    body,
-    headers
-  });
-
-  // We leverage the fact, that our internal /toke/tenant API returns data in the same format as Auth
-  return response.json();
-};
-export const mediaPickerAuthProvider = (authEnvironment = 'asap', env) => context => {
-  const collectionName = context && context.collectionName || defaultCollectionName;
-  authEnvironment = authEnvironment === 'asap' ? 'asap' : '';
-  const cacheKey = `${collectionName}:${authEnvironment}`;
-  if (!cachedAuths[cacheKey]) {
-    cachedAuths[cacheKey] = requestAuthProvider(authEnvironment, collectionName, env);
-  }
-  return cachedAuths[cacheKey];
-};
-export const defaultMediaPickerAuthProvider = () => () => {
-  const auth = {
-    clientId: 'a89be2a1-f91f-485c-9962-a8fb25ccfa13',
-    token: 'eyJ0eXAiOiJKV1QiLCJhbGciOiJIUzI1NiJ9.eyJpc3MiOiJhODliZTJhMS1mOTFmLTQ4NWMtOTk2Mi1hOGZiMjVjY2ZhMTMiLCJ1bnNhZmUiOnRydWUsImlhdCI6MTQ3MzIyNTEzNn0.6Isj5jKgKzWDnPqfoMLiC_LVIlGM8kg_wxG6eGGwhTw',
-    baseUrl: authProviderBaseURL
-  };
-  return Promise.resolve(auth);
-};

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

@@ -1,423 +0,0 @@
-import _asyncToGenerator from "@babel/runtime/helpers/asyncToGenerator";
-import _regeneratorRuntime from "@babel/runtime/regenerator";
-import { getMediaFile, normaliseInput } from './helpers';
-var getMediaApi = function getMediaApi(_ref) {
-  var getItem = _ref.getItem;
-  return {
-    // --------------------------------------------------------
-    // UPLOAD ENDPOINTS - None is supported
-    // --------------------------------------------------------
-
-    touchFiles: function () {
-      var _touchFiles = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee(_ref2) {
-        var descriptors;
-        return _regeneratorRuntime.wrap(function _callee$(_context) {
-          while (1) switch (_context.prev = _context.next) {
-            case 0:
-              descriptors = _ref2.descriptors;
-              throw new Error('500 - MockedMediaApi.touchFiles: method not implemented');
-            case 2:
-            case "end":
-              return _context.stop();
-          }
-        }, _callee);
-      }));
-      function touchFiles(_x) {
-        return _touchFiles.apply(this, arguments);
-      }
-      return touchFiles;
-    }(),
-    uploadChunk: function () {
-      var _uploadChunk = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee2(_etag, _blob, uploadId) {
-        return _regeneratorRuntime.wrap(function _callee2$(_context2) {
-          while (1) switch (_context2.prev = _context2.next) {
-            case 0:
-              throw new Error('500 - MockedMediaApi.uploadChunk: method not implemented');
-            case 1:
-            case "end":
-              return _context2.stop();
-          }
-        }, _callee2);
-      }));
-      function uploadChunk(_x2, _x3, _x4) {
-        return _uploadChunk.apply(this, arguments);
-      }
-      return uploadChunk;
-    }(),
-    appendChunksToUpload: function () {
-      var _appendChunksToUpload = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee3() {
-        return _regeneratorRuntime.wrap(function _callee3$(_context3) {
-          while (1) switch (_context3.prev = _context3.next) {
-            case 0:
-              throw new Error('500 - MockedMediaApi.appendChunksToUpload: method not implemented');
-            case 1:
-            case "end":
-              return _context3.stop();
-          }
-        }, _callee3);
-      }));
-      function appendChunksToUpload() {
-        return _appendChunksToUpload.apply(this, arguments);
-      }
-      return appendChunksToUpload;
-    }(),
-    createFileFromUpload: function () {
-      var _createFileFromUpload = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee4(_ref3, _ref4) {
-        var uploadId, collection;
-        return _regeneratorRuntime.wrap(function _callee4$(_context4) {
-          while (1) switch (_context4.prev = _context4.next) {
-            case 0:
-              uploadId = _ref3.uploadId;
-              collection = _ref4.collection;
-              throw new Error('500 - MockedMediaApi.createFileFromUpload: method not implemented');
-            case 3:
-            case "end":
-              return _context4.stop();
-          }
-        }, _callee4);
-      }));
-      function createFileFromUpload(_x5, _x6) {
-        return _createFileFromUpload.apply(this, arguments);
-      }
-      return createFileFromUpload;
-    }(),
-    // Used by Media Picker as a fallback for conflicted file Ids
-    createUpload: function () {
-      var _createUpload = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee5() {
-        return _regeneratorRuntime.wrap(function _callee5$(_context5) {
-          while (1) switch (_context5.prev = _context5.next) {
-            case 0:
-              throw new Error('500 - MockedMediaApi.createUpload: method not implemented');
-            case 1:
-            case "end":
-              return _context5.stop();
-          }
-        }, _callee5);
-      }));
-      function createUpload() {
-        return _createUpload.apply(this, arguments);
-      }
-      return createUpload;
-    }(),
-    // For File size limits
-    getRejectedResponseFromDescriptor: function getRejectedResponseFromDescriptor() {
-      throw new Error('500 - MockedMediaApi.getRejectedResponseFromDescriptor: method not implemented');
-    },
-    // --------------------------------------------------------
-    // METADATA ENDPOINTS
-    // --------------------------------------------------------
-
-    getFile: function () {
-      var _getFile = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee6(fileId) {
-        var fileItem;
-        return _regeneratorRuntime.wrap(function _callee6$(_context6) {
-          while (1) switch (_context6.prev = _context6.next) {
-            case 0:
-              fileItem = getItem(fileId);
-              if (fileItem) {
-                _context6.next = 3;
-                break;
-              }
-              throw new Error('404 - MockedMediaApi.getFile: file not found');
-            case 3:
-              return _context6.abrupt("return", {
-                data: getMediaFile(fileItem)
-              });
-            case 4:
-            case "end":
-              return _context6.stop();
-          }
-        }, _callee6);
-      }));
-      function getFile(_x7) {
-        return _getFile.apply(this, arguments);
-      }
-      return getFile;
-    }(),
-    getItems: function () {
-      var _getItems = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee7(ids) {
-        var items;
-        return _regeneratorRuntime.wrap(function _callee7$(_context7) {
-          while (1) switch (_context7.prev = _context7.next) {
-            case 0:
-              items = ids.map(function (id) {
-                return getItem(id);
-              }).filter(function (fileState) {
-                return !!fileState;
-              });
-              return _context7.abrupt("return", {
-                data: {
-                  items: items
-                }
-              });
-            case 2:
-            case "end":
-              return _context7.stop();
-          }
-        }, _callee7);
-      }));
-      function getItems(_x8) {
-        return _getItems.apply(this, arguments);
-      }
-      return getItems;
-    }(),
-    // TODO
-    getImageMetadata: function () {
-      var _getImageMetadata = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee8() {
-        return _regeneratorRuntime.wrap(function _callee8$(_context8) {
-          while (1) switch (_context8.prev = _context8.next) {
-            case 0:
-              throw new Error('500 - MockedMediaApi.getImageMetadata: method not implemented');
-            case 1:
-            case "end":
-              return _context8.stop();
-          }
-        }, _callee8);
-      }));
-      function getImageMetadata() {
-        return _getImageMetadata.apply(this, arguments);
-      }
-      return getImageMetadata;
-    }(),
-    // --------------------------------------------------------
-    // URL ENDPOINTS
-    // --------------------------------------------------------
-
-    getFileImageURL: function () {
-      var _getFileImageURL = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee9(id) {
-        return _regeneratorRuntime.wrap(function _callee9$(_context9) {
-          while (1) switch (_context9.prev = _context9.next) {
-            case 0:
-              return _context9.abrupt("return", "image-url-".concat(id));
-            case 1:
-            case "end":
-              return _context9.stop();
-          }
-        }, _callee9);
-      }));
-      function getFileImageURL(_x9) {
-        return _getFileImageURL.apply(this, arguments);
-      }
-      return getFileImageURL;
-    }(),
-    getFileImageURLSync: function getFileImageURLSync(id) {
-      return "image-url-sync-".concat(id);
-    },
-    getFileBinaryURL: function () {
-      var _getFileBinaryURL = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee10(id) {
-        var fileItem;
-        return _regeneratorRuntime.wrap(function _callee10$(_context10) {
-          while (1) switch (_context10.prev = _context10.next) {
-            case 0:
-              fileItem = getItem(id);
-              if (fileItem) {
-                _context10.next = 3;
-                break;
-              }
-              throw new Error('404 - MockedMediaApi.getFileBinaryURL: file not found');
-            case 3:
-              if (!(fileItem.details.size === 0)) {
-                _context10.next = 5;
-                break;
-              }
-              throw new Error('404 - MockedMediaApi.getFileBinaryURL: file is empty');
-            case 5:
-              return _context10.abrupt("return", "/file/".concat(id, "/binary"));
-            case 6:
-            case "end":
-              return _context10.stop();
-          }
-        }, _callee10);
-      }));
-      function getFileBinaryURL(_x10) {
-        return _getFileBinaryURL.apply(this, arguments);
-      }
-      return getFileBinaryURL;
-    }(),
-    getArtifactURL: function () {
-      var _getArtifactURL = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee11(artifacts, artifactName) {
-        var _artifacts$artifactNa;
-        var artifactUrl;
-        return _regeneratorRuntime.wrap(function _callee11$(_context11) {
-          while (1) switch (_context11.prev = _context11.next) {
-            case 0:
-              artifactUrl = (_artifacts$artifactNa = artifacts[artifactName]) === null || _artifacts$artifactNa === void 0 ? void 0 : _artifacts$artifactNa.url;
-              if (artifactUrl) {
-                _context11.next = 3;
-                break;
-              }
-              throw new Error("404 - MockedMediaApi.getArtifactURL: artifact ".concat(artifactName, " not found"));
-            case 3:
-              return _context11.abrupt("return", artifactUrl);
-            case 4:
-            case "end":
-              return _context11.stop();
-          }
-        }, _callee11);
-      }));
-      function getArtifactURL(_x11, _x12) {
-        return _getArtifactURL.apply(this, arguments);
-      }
-      return getArtifactURL;
-    }(),
-    // --------------------------------------------------------
-    // BINARY ENDPOINTS
-    // --------------------------------------------------------
-    getImage: function () {
-      var _getImage = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee12(fileId) {
-        var fileItem;
-        return _regeneratorRuntime.wrap(function _callee12$(_context12) {
-          while (1) switch (_context12.prev = _context12.next) {
-            case 0:
-              fileItem = getItem(fileId);
-              if (fileItem) {
-                _context12.next = 3;
-                break;
-              }
-              throw new Error('404 - MockedMediaApi.getImage: file not found');
-            case 3:
-              if (fileItem.details.representations.image) {
-                _context12.next = 5;
-                break;
-              }
-              throw new Error('404 - MockedMediaApi.getImage: image not found');
-            case 5:
-              return _context12.abrupt("return", new Blob());
-            case 6:
-            case "end":
-              return _context12.stop();
-          }
-        }, _callee12);
-      }));
-      function getImage(_x13) {
-        return _getImage.apply(this, arguments);
-      }
-      return getImage;
-    }(),
-    // --------------------------------------------------------
-    // OTHER ENDPOINTS
-    // --------------------------------------------------------
-
-    // TODO
-    copyFileWithToken: function () {
-      var _copyFileWithToken = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee13(body) {
-        var fileId, fileItem;
-        return _regeneratorRuntime.wrap(function _callee13$(_context13) {
-          while (1) switch (_context13.prev = _context13.next) {
-            case 0:
-              fileId = body.sourceFile.id;
-              fileItem = getItem(fileId);
-              if (fileItem) {
-                _context13.next = 4;
-                break;
-              }
-              throw new Error('404 - MockedMediaApi.copyFileWithToken: file not found');
-            case 4:
-              return _context13.abrupt("return", {
-                data: getMediaFile(fileItem)
-              });
-            case 5:
-            case "end":
-              return _context13.stop();
-          }
-        }, _callee13);
-      }));
-      function copyFileWithToken(_x14) {
-        return _copyFileWithToken.apply(this, arguments);
-      }
-      return copyFileWithToken;
-    }(),
-    // TODO
-    removeCollectionFile: function () {
-      var _removeCollectionFile = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee14() {
-        return _regeneratorRuntime.wrap(function _callee14$(_context14) {
-          while (1) switch (_context14.prev = _context14.next) {
-            case 0:
-            case "end":
-              return _context14.stop();
-          }
-        }, _callee14);
-      }));
-      function removeCollectionFile() {
-        return _removeCollectionFile.apply(this, arguments);
-      }
-      return removeCollectionFile;
-    }(),
-    // --------------------------------------------------------
-    // OTHER ENDPOINTS
-    // --------------------------------------------------------
-    request: function () {
-      var _request = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee15() {
-        return _regeneratorRuntime.wrap(function _callee15$(_context15) {
-          while (1) switch (_context15.prev = _context15.next) {
-            case 0:
-              return _context15.abrupt("return", new Response());
-            case 1:
-            case "end":
-              return _context15.stop();
-          }
-        }, _callee15);
-      }));
-      function request() {
-        return _request.apply(this, arguments);
-      }
-      return request;
-    }(),
-    resolveAuth: function () {
-      var _resolveAuth = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee16() {
-        return _regeneratorRuntime.wrap(function _callee16$(_context16) {
-          while (1) switch (_context16.prev = _context16.next) {
-            case 0:
-              return _context16.abrupt("return", {
-                asapIssuer: '',
-                token: '',
-                baseUrl: ''
-              });
-            case 1:
-            case "end":
-              return _context16.stop();
-          }
-        }, _callee16);
-      }));
-      function resolveAuth() {
-        return _resolveAuth.apply(this, arguments);
-      }
-      return resolveAuth;
-    }(),
-    resolveInitialAuth: function resolveInitialAuth() {
-      return {
-        asapIssuer: '',
-        token: '',
-        baseUrl: ''
-      };
-    }
-  };
-};
-
-/**
- * Mocked Media API
- */
-export var createMockedMediaApi = function createMockedMediaApi(initialFileItems) {
-  var storedFileItems = new Map();
-  var getItem = function getItem(fileId) {
-    return storedFileItems.get(fileId);
-  };
-  var setItems = function setItems(fileItems) {
-    var normalised = normaliseInput(fileItems);
-    normalised.forEach(function (fileItem) {
-      return storedFileItems.set(fileItem.id, fileItem);
-    });
-  };
-  if (initialFileItems) {
-    setItems(initialFileItems);
-  }
-  var mediaApi = getMediaApi({
-    setItems: setItems,
-    getItem: getItem
-  });
-  return {
-    setItems: setItems,
-    getItem: getItem,
-    mediaApi: mediaApi
-  };
-};