@atlaskit/media-client 39.1.19 → 39.2.0

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

@@ -0,0 +1,56 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.authProviderBaseURL = exports.accessUrns = void 0;
+Object.defineProperty(exports, "defaultMediaPickerAuthProvider", {
+  enumerable: true,
+  get: function get() {
+    return _defaultMediaPickerAuthProvider.defaultMediaPickerAuthProvider;
+  }
+});
+exports.mediaPickerAuthProvider = void 0;
+var _cachedAuths = require("./cachedAuths");
+var _collectionNames = require("./collectionNames");
+var _requestAuthProvider = require("./requestAuthProvider");
+var _defaultMediaPickerAuthProvider = require("./defaultMediaPickerAuthProvider");
+/* eslint-disable @repo/internal/deprecations/deprecation-ticket-required -- VOLTC-139 tracks removal of these deprecated re-export shims. */
+
+var authProviderBaseURL = exports.authProviderBaseURL = 'https://media.staging.atl-paas.net';
+var accessUrns = exports.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']
+  }
+};
+var mediaPickerAuthProvider = exports.mediaPickerAuthProvider = function mediaPickerAuthProvider() {
+  var authEnvironment = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 'asap';
+  var env = arguments.length > 1 ? arguments[1] : undefined;
+  return function (context) {
+    var collectionName = context && context.collectionName || _collectionNames.defaultCollectionName;
+    authEnvironment = authEnvironment === 'asap' ? 'asap' : '';
+    var cacheKey = "".concat(collectionName, ":").concat(authEnvironment);
+    if (!_cachedAuths.cachedAuths[cacheKey]) {
+      _cachedAuths.cachedAuths[cacheKey] = (0, _requestAuthProvider.requestAuthProvider)(authEnvironment, collectionName, env);
+    }
+    return _cachedAuths.cachedAuths[cacheKey];
+  };
+};
+
+/**
+ * @deprecated Use `import { defaultMediaPickerAuthProvider } from '@atlaskit/media-client/test-helpers'` instead.
+ */

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

@@ -0,0 +1,48 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.requestAuthProvider = void 0;
+var _regenerator = _interopRequireDefault(require("@babel/runtime/regenerator"));
+var _asyncToGenerator2 = _interopRequireDefault(require("@babel/runtime/helpers/asyncToGenerator"));
+var _mediaPickerAuthProvider = require("./mediaPickerAuthProvider");
+var requestAuthProvider = exports.requestAuthProvider = /*#__PURE__*/function () {
+  var _ref = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee(authEnvironment, collectionName) {
+    var env,
+      url,
+      body,
+      headers,
+      response,
+      _args = arguments;
+    return _regenerator.default.wrap(function (_context) {
+      while (1) switch (_context.prev = _context.next) {
+        case 0:
+          env = _args.length > 2 && _args[2] !== undefined ? _args[2] : 'staging';
+          url = "https://media-playground.".concat(env, ".atl-paas.net/token/tenant?environment=").concat(authEnvironment);
+          body = JSON.stringify({
+            access: _mediaPickerAuthProvider.accessUrns[collectionName] || {}
+          });
+          headers = new Headers();
+          headers.append('Content-Type', 'application/json; charset=utf-8');
+          headers.append('Accept', 'text/plain, */*; q=0.01');
+          _context.next = 1;
+          return fetch(url, {
+            method: 'POST',
+            body: body,
+            headers: headers
+          });
+        case 1:
+          response = _context.sent;
+          return _context.abrupt("return", response.json());
+        case 2:
+        case "end":
+          return _context.stop();
+      }
+    }, _callee);
+  }));
+  return function requestAuthProvider(_x, _x2) {
+    return _ref.apply(this, arguments);
+  };
+}();

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

@@ -0,0 +1,205 @@
+import { getMediaFile } from './getMediaFile';
+import { normaliseInput } from './normaliseInput';
+const getMediaApi = ({
+  getItem
+}) => ({
+  // --------------------------------------------------------
+  // UPLOAD ENDPOINTS - None is supported
+  // --------------------------------------------------------
+
+  touchFiles: async ({
+    descriptors
+  }) => {
+    throw new Error('500 - MockedMediaApi.touchFiles: 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 = getItem(fileId);
+    if (!fileItem) {
+      throw new Error('404 - MockedMediaApi.getFile: file not found');
+    }
+    return {
+      data: getMediaFile(fileItem)
+    };
+  },
+  getItems: async ids => {
+    const items = ids.map(id => getItem(id)).filter(fileState => !!fileState);
+    return {
+      data: {
+        items
+      }
+    };
+  },
+  // TODO
+  getImageMetadata: async () => {
+    throw new Error('500 - MockedMediaApi.getImageMetadata: method not implemented');
+  },
+  // --------------------------------------------------------
+  // URL ENDPOINTS
+  // --------------------------------------------------------
+
+  getFileImageURL: async id => {
+    return `image-url-${id}`;
+  },
+  getFileImageURLSync: id => {
+    return `image-url-sync-${id}`;
+  },
+  getFileBinaryURL: async id => {
+    const fileItem = getItem(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;
+  },
+  getArtifactBinary: async (artifacts, artifactName) => {
+    var _artifacts$artifactNa2, _artifacts$artifactNa3;
+    const artifactUrl = ((_artifacts$artifactNa2 = artifacts[artifactName]) === null || _artifacts$artifactNa2 === void 0 ? void 0 : _artifacts$artifactNa2.url) || ((_artifacts$artifactNa3 = artifacts[artifactName]) === null || _artifacts$artifactNa3 === void 0 ? void 0 : _artifacts$artifactNa3.cdnUrl);
+    if (!artifactUrl) {
+      throw new Error(`404 - MockedMediaApi.getArtifactBinary: artifact ${artifactName} URL not found`);
+    }
+    return new Blob();
+  },
+  uploadArtifact: async id => {
+    const item = getItem(id);
+    if (!item) {
+      throw new Error('404 - MockedMediaApi.uploadArtifact: file not found');
+    }
+    return {
+      data: item.details
+    };
+  },
+  deleteArtifact: async id => {
+    // OK!
+    // TODO: this should return the item details
+  },
+  // --------------------------------------------------------
+  // BINARY ENDPOINTS
+  // --------------------------------------------------------
+  getImage: async fileId => {
+    const fileItem = getItem(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();
+  },
+  getFileBinary: async fileId => {
+    const fileItem = getItem(fileId);
+    if (!fileItem) {
+      throw new Error('404 - MockedMediaApi.getFileBinary: file not found');
+    }
+    return new Blob();
+  },
+  // --------------------------------------------------------
+  // OTHER ENDPOINTS
+  // --------------------------------------------------------
+
+  // TODO
+  copyFileWithToken: async body => {
+    const fileId = body.sourceFile.id;
+    const fileItem = getItem(fileId);
+    if (!fileItem) {
+      throw new Error('404 - MockedMediaApi.copyFileWithToken: file not found');
+    }
+    return {
+      data: getMediaFile(fileItem)
+    };
+  },
+  copyFile: async (fileId, params) => {
+    const fileItem = getItem(fileId);
+    if (!fileItem) {
+      throw new Error('404 - MockedMediaApi.copy: file not found');
+    }
+    return {
+      data: getMediaFile(fileItem)
+    };
+  },
+  registerCopyIntents: async (ids, collectionName) => {},
+  // TODO
+  removeCollectionFile: async () => {},
+  // --------------------------------------------------------
+  // OTHER ENDPOINTS
+  // --------------------------------------------------------
+  request: async () => new Response(),
+  resolveAuth: async () => ({
+    asapIssuer: '',
+    token: '',
+    baseUrl: ''
+  }),
+  resolveInitialAuth: () => ({
+    asapIssuer: '',
+    token: '',
+    baseUrl: ''
+  }),
+  getDocumentContent: async () => {
+    throw new Error('500 - MockedMediaApi.getDocumentContent: method not implemented');
+  },
+  getDocumentPageImage: async () => {
+    throw new Error('500 - MockedMediaApi.getDocumentPageImage: method not implemented');
+  },
+  testUrl: async () => {}
+});
+
+/**
+ * Mocked Media API
+ */
+export const createMockedMediaApi = initialFileItems => {
+  const storedFileItems = new Map();
+  const getItem = fileId => storedFileItems.get(fileId);
+  const setItems = fileItems => {
+    const normalised = normaliseInput(fileItems);
+    normalised.forEach(fileItem => storedFileItems.set(fileItem.id, fileItem));
+  };
+  if (initialFileItems) {
+    setItems(initialFileItems);
+  }
+  const mediaApi = getMediaApi({
+    setItems,
+    getItem
+  });
+  return {
+    setItems,
+    getItem,
+    mediaApi
+  };
+};

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

@@ -0,0 +1,18 @@
+/**
+ * Adds/overrides the attributes from fileItemB into the fileItemA
+ * */
+export const assign = (fileItemA, fileItemB) => {
+  var _fileItemA$details, _fileItemB$details;
+  return {
+    ...fileItemA,
+    ...fileItemB,
+    details: {
+      ...fileItemA.details,
+      ...(fileItemB === null || fileItemB === void 0 ? void 0 : fileItemB.details),
+      artifacts: {
+        ...((_fileItemA$details = fileItemA.details) === null || _fileItemA$details === void 0 ? void 0 : _fileItemA$details.artifacts),
+        ...(fileItemB === null || fileItemB === void 0 ? void 0 : (_fileItemB$details = fileItemB.details) === null || _fileItemB$details === void 0 ? void 0 : _fileItemB$details.artifacts)
+      }
+    }
+  };
+};

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

@@ -0,0 +1,8 @@
+import { v4 as uuid } from 'uuid'; // eslint-disable-line @atlaskit/platform/prefer-crypto-random-uuid -- Use crypto.randomUUID instead
+
+/**
+ * Makes a copy of the provided file item with a random file id
+ * */
+export const copy = fileItem =>
+// eslint-disable-next-line @atlaskit/platform/prefer-crypto-random-uuid -- Use crypto.randomUUID instead
+JSON.parse(JSON.stringify(fileItem).replace(new RegExp(fileItem.id, 'g'), uuid()));

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

@@ -0,0 +1,23 @@
+// --------------------------------------------------------
+// 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;
+};

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

@@ -0,0 +1,6 @@
+import { fromCommonMediaClientError } from '../../models/errors/fromCommonMediaClientError';
+import { createServerUnauthorizedError } from '../createServerUnauthorizedError';
+const defaultErrorFileStateError = createServerUnauthorizedError();
+export const createErrorFileState = ({
+  id
+}, error = defaultErrorFileStateError) => fromCommonMediaClientError(id, undefined, error);

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

@@ -0,0 +1,23 @@
+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
+});

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

@@ -0,0 +1,53 @@
+/**
+ * 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);
+
+  // 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: {}
+    }
+  };
+};

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

@@ -0,0 +1,24 @@
+export const createUploadingFileState = ({
+  id,
+  details: {
+    name,
+    size,
+    mediaType,
+    mimeType,
+    createdAt
+  }
+}, progress, binary) => ({
+  status: 'uploading',
+  progress,
+  id,
+  name,
+  size,
+  mediaType,
+  mimeType,
+  createdAt,
+  preview: {
+    value: binary || new Blob(['some-content'], {
+      type: mimeType
+    })
+  }
+});

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

@@ -0,0 +1,8 @@
+/**
+ * Extracts the file identifier from the provided file item
+ */
+export const getIdentifier = fileItem => ({
+  mediaItemType: 'file',
+  id: fileItem.id,
+  collectionName: fileItem.collection
+});

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

@@ -0,0 +1,7 @@
+// --------------------------------------------------------
+// Utils for the main class
+// --------------------------------------------------------
+export const getMediaFile = fileItem => ({
+  id: fileItem.id,
+  ...fileItem.details
+});

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

@@ -0,0 +1,47 @@
+/* eslint-disable @repo/internal/deprecations/deprecation-ticket-required -- VOLTC-139 tracks removal of these deprecated re-export shims. */
+
+/**
+ * @deprecated Use `import { normaliseInput } from '@atlaskit/media-client/test-helpers/mocked-media-api/helpers'` instead.
+ */
+
+export { normaliseInput } from './normaliseInput';
+/**
+ * @deprecated Use `import { getMediaFile } from '@atlaskit/media-client/test-helpers/mocked-media-api/helpers'` instead.
+ */
+export { getMediaFile } from './getMediaFile';
+/**
+ * @deprecated Use `import { createEmptyFileItem } from '@atlaskit/media-client/test-helpers'` instead.
+ */
+export { createEmptyFileItem } from './createEmptyFileItem';
+/**
+ * @deprecated Use `import { createProcessingFileItem } from '@atlaskit/media-client/test-helpers'` instead.
+ */
+export { createProcessingFileItem } from './createProcessingFileItem';
+/**
+ * @deprecated Use `import { copy } from '@atlaskit/media-client/test-helpers'` instead.
+ */
+export { copy } from './copy';
+/**
+ * @deprecated Use `import { merge } from '@atlaskit/media-client/test-helpers'` instead.
+ */
+export { merge } from './merge';
+/**
+ * @deprecated Use `import { assign } from '@atlaskit/media-client/test-helpers'` instead.
+ */
+export { assign } from './assign';
+/**
+ * @deprecated Use `import { getIdentifier } from '@atlaskit/media-client/test-helpers'` instead.
+ */
+export { getIdentifier } from './getIdentifier';
+/**
+ * @deprecated Use `import { createFileState } from '@atlaskit/media-client/test-helpers'` instead.
+ */
+export { createFileState } from './createFileState';
+/**
+ * @deprecated Use `import { createUploadingFileState } from '@atlaskit/media-client/test-helpers'` instead.
+ */
+export { createUploadingFileState } from './createUploadingFileState';
+/**
+ * @deprecated Use `import { createErrorFileState } from '@atlaskit/media-client/test-helpers'` instead.
+ */
+export { createErrorFileState } from './createErrorFileState';

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

@@ -0,0 +1,18 @@
+/**
+ * Adds/overrides the attributes from fileItemB into the fileItemA
+ * */
+export const merge = (fileItemA, fileItemB) => {
+  var _fileItemA$details, _fileItemB$details;
+  return {
+    ...fileItemA,
+    ...fileItemB,
+    details: {
+      ...(fileItemA === null || fileItemA === void 0 ? void 0 : fileItemA.details),
+      ...(fileItemB === null || fileItemB === void 0 ? void 0 : fileItemB.details),
+      artifacts: {
+        ...(fileItemA === null || fileItemA === void 0 ? void 0 : (_fileItemA$details = fileItemA.details) === null || _fileItemA$details === void 0 ? void 0 : _fileItemA$details.artifacts),
+        ...(fileItemB === null || fileItemB === void 0 ? void 0 : (_fileItemB$details = fileItemB.details) === null || _fileItemB$details === void 0 ? void 0 : _fileItemB$details.artifacts)
+      }
+    }
+  };
+};

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

@@ -0,0 +1,4 @@
+// --------------------------------------------------------
+// Factory Utils
+// --------------------------------------------------------
+export const normaliseInput = input => !input ? [] : input instanceof Array ? input : [input];

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

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

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

@@ -0,0 +1,3 @@
+export function numbers(count) {
+  return Array.from(Array(count).keys());
+}

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

@@ -0,0 +1,34 @@
+import { defaultCollectionName } from './collectionNames';
+const cachedAuths = {};
+const authProviderBaseURL = 'https://media-playground.dev.atl-paas.net/';
+export class StoryBookAuthProvider {
+  static create(isAsapEnvironment, access) {
+    const loadTenatAuth = async collectionName => {
+      const environment = isAsapEnvironment ? 'asap' : '';
+      const headers = new Headers();
+      headers.append('Content-Type', 'application/json; charset=utf-8');
+      headers.append('Accept', 'text/plain, */*; q=0.01');
+      const config = {
+        method: 'POST',
+        headers,
+        body: access ? JSON.stringify({
+          access
+        }) : undefined
+      };
+      const url = `${authProviderBaseURL}/token/tenant?collection=${collectionName}&environment=${environment}`;
+      const response = fetch(url, config);
+
+      // We leverage the fact, that our internal /toke/tenant API returns data in the same format as Auth
+      return await (await response).json();
+    };
+    return authContext => {
+      const collectionName = authContext && authContext.collectionName || defaultCollectionName;
+      const accessStr = access ? JSON.stringify(access) : '';
+      const cacheKey = `${collectionName}-${accessStr}-${isAsapEnvironment}`;
+      if (!cachedAuths[cacheKey]) {
+        cachedAuths[cacheKey] = loadTenatAuth(collectionName);
+      }
+      return cachedAuths[cacheKey];
+    };
+  }
+}

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

@@ -0,0 +1 @@
+export const cachedAuths = {};

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

@@ -0,0 +1,5 @@
+export const defaultCollectionName = 'MediaServicesSample';
+export const onlyAnimatedGifsCollectionName = 'only-animated-gifs';
+export const fileCollectionName = `${defaultCollectionName}Files`;
+export const defaultMediaPickerCollectionName = 'mediapicker-test';
+export const collectionNames = [defaultCollectionName, 'MediaServicesSampleAtlaskit', 'MediaServicesSampleHulk', 'MediaServicesSampleFabric', fileCollectionName, onlyAnimatedGifsCollectionName, defaultMediaPickerCollectionName];

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

@@ -0,0 +1,2 @@
+import { MediaStoreError } from '../client/media-store/MediaStoreError';
+export const createMediaStoreError = () => new MediaStoreError('missingInitialAuth');

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

@@ -0,0 +1,4 @@
+import { PollingError } from '../utils/polling';
+export const createPollingMaxAttemptsError = (attempts = 1) => new PollingError('pollingMaxAttemptsExceeded', {
+  attempts
+});

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

@@ -0,0 +1,6 @@
+import { RequestError } from '../utils/request';
+import { defaultMetadata } from './defaultMetadata';
+export const createRateLimitedError = (metadataAndHeaders = defaultMetadata) => new RequestError('serverRateLimited', {
+  ...metadataAndHeaders,
+  statusCode: 429
+});

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

@@ -0,0 +1,6 @@
+import { RequestError } from '../utils/request';
+import { defaultMetadata } from './defaultMetadata';
+export const createServerUnauthorizedError = (metadataAndHeaders = defaultMetadata, innerError) => new RequestError('serverUnauthorized', {
+  ...metadataAndHeaders,
+  statusCode: 403
+}, innerError || new Error('inner error message'));

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

@@ -0,0 +1,13 @@
+import { MediaClient } from '..';
+import { createStorybookMediaClientConfig } from './createStorybookMediaClientConfig';
+import { defaultAuthParameter } from './defaultAuthParameter';
+
+/**
+ * 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));
+};