@atlaskit/media-client 25.0.1 → 25.0.3

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

@@ -1,386 +1,2 @@
-import _defineProperty from "@babel/runtime/helpers/defineProperty";
-import { getRandomHex } from '@atlaskit/media-common';
-import { FILE_CACHE_MAX_AGE, MAX_RESOLUTION } from '../../constants';
-import { getArtifactUrl } from '../../models/artifacts';
-import { request } from '../../utils/request';
-import { createUrl, createMapResponseToJson, createMapResponseToBlob } from '../../utils/request/helpers';
-import { resolveAuth, resolveInitialAuth } from './resolveAuth';
 export { MediaStoreError, isMediaStoreError } from './error';
-const MEDIA_API_REGION = 'media-api-region';
-const MEDIA_API_ENVIRONMENT = 'media-api-environment';
-const defaultImageOptions = {
-  'max-age': FILE_CACHE_MAX_AGE,
-  allowAnimated: true,
-  mode: 'crop'
-};
-const extendImageParams = (params, fetchMaxRes = false) => {
-  return {
-    ...defaultImageOptions,
-    ...params,
-    ...(fetchMaxRes ? {
-      width: MAX_RESOLUTION,
-      height: MAX_RESOLUTION
-    } : {})
-  };
-};
-const jsonHeaders = {
-  Accept: 'application/json',
-  'Content-Type': 'application/json'
-};
-export class MediaStore {
-  constructor(config) {
-    _defineProperty(this, "resolveAuth", authContext => resolveAuth(this.config.authProvider, authContext));
-    _defineProperty(this, "resolveInitialAuth", () => resolveInitialAuth(this.config.initialAuth));
-    this.config = config;
-  }
-  async removeCollectionFile(id, collectionName, occurrenceKey, traceContext) {
-    const metadata = {
-      method: 'PUT',
-      endpoint: '/collection/{collectionName}'
-    };
-    const body = {
-      actions: [{
-        action: 'remove',
-        item: {
-          type: 'file',
-          id,
-          occurrenceKey
-        }
-      }]
-    };
-    const options = {
-      ...metadata,
-      authContext: {
-        collectionName
-      },
-      headers: {
-        Accept: 'application/json',
-        'Content-Type': 'application/json'
-      },
-      body: JSON.stringify(body),
-      traceContext
-    };
-    await this.request(`/collection/${collectionName}`, options);
-  }
-  createUpload(createUpTo = 1, collectionName, traceContext) {
-    const metadata = {
-      method: 'POST',
-      endpoint: '/upload'
-    };
-    const options = {
-      ...metadata,
-      authContext: {
-        collectionName
-      },
-      params: {
-        createUpTo
-      },
-      headers: {
-        Accept: 'application/json'
-      },
-      traceContext
-    };
-    return this.request(`/upload`, options).then(createMapResponseToJson(metadata));
-  }
-  async uploadChunk(etag, blob, uploadId, partNumber, collectionName, traceContext) {
-    const metadata = {
-      method: 'PUT',
-      endpoint: '/chunk/{etag}'
-    };
-    const options = {
-      ...metadata,
-      params: {
-        uploadId,
-        partNumber
-      },
-      authContext: {
-        collectionName
-      },
-      body: blob,
-      traceContext
-    };
-    await this.request(`/chunk/${etag}`, options);
-  }
-  probeChunks(chunks, uploadId, collectionName, traceContext) {
-    const metadata = {
-      method: 'POST',
-      endpoint: '/chunk/probe'
-    };
-    const options = {
-      ...metadata,
-      params: {
-        uploadId
-      },
-      authContext: {
-        collectionName
-      },
-      headers: jsonHeaders,
-      body: JSON.stringify({
-        chunks
-      }),
-      traceContext
-    };
-    return this.request(`/chunk/probe`, options).then(createMapResponseToJson(metadata));
-  }
-  createFileFromUpload(body, params = {}, traceContext) {
-    const metadata = {
-      method: 'POST',
-      endpoint: '/file/upload'
-    };
-    const options = {
-      ...metadata,
-      authContext: {
-        collectionName: params.collection
-      },
-      params,
-      headers: jsonHeaders,
-      body: JSON.stringify(body),
-      traceContext
-    };
-    return this.request('/file/upload', options).then(createMapResponseToJson(metadata));
-  }
-  getRejectedResponseFromDescriptor(descriptor, limit) {
-    return {
-      fileId: descriptor.fileId,
-      error: {
-        code: 'ExceedMaxFileSizeLimit',
-        title: 'The expected file size exceeded the maximum size limit.',
-        href: 'https://dt-api-filestore--app.ap-southeast-2.dev.atl-paas.net/api.html#BadRequest',
-        limit,
-        size: descriptor.size
-      }
-    };
-  }
-  async touchFiles(body, params = {}, traceContext) {
-    const metadata = {
-      method: 'POST',
-      endpoint: '/upload/createWithFiles'
-    };
-    const options = {
-      ...metadata,
-      authContext: {
-        collectionName: params.collection
-      },
-      headers: jsonHeaders,
-      body: JSON.stringify(body),
-      traceContext
-    };
-    return this.request('/upload/createWithFiles', options).then(createMapResponseToJson(metadata));
-  }
-  getFile(fileId, params = {}, traceContext) {
-    const metadata = {
-      method: 'GET',
-      endpoint: '/file/{fileId}'
-    };
-    const options = {
-      ...metadata,
-      authContext: {
-        collectionName: params.collection
-      },
-      params,
-      traceContext
-    };
-    return this.request(`/file/${fileId}`, options).then(createMapResponseToJson(metadata));
-  }
-  async getFileImageURL(id, params) {
-    const {
-      collection: collectionName
-    } = params || {};
-    const auth = await this.resolveAuth({
-      collectionName
-    });
-    return this.createFileImageURL(id, auth, params);
-  }
-
-  // TODO Create ticket in case Trace Id can be supported through query params
-  getFileImageURLSync(id, params) {
-    const auth = this.resolveInitialAuth();
-    return this.createFileImageURL(id, auth, params);
-  }
-  createFileImageURL(id, auth, params) {
-    const options = {
-      params: extendImageParams(params),
-      auth
-    };
-    return createUrl(`${auth.baseUrl}/file/${id}/image`, options);
-  }
-  async getFileBinaryURL(id, collectionName) {
-    const auth = await this.resolveAuth({
-      collectionName
-    });
-    const options = {
-      params: {
-        dl: true,
-        collection: collectionName,
-        'max-age': FILE_CACHE_MAX_AGE
-      },
-      auth
-    };
-    return createUrl(`${auth.baseUrl}/file/${id}/binary`, options);
-  }
-  async getArtifactURL(artifacts, artifactName, collectionName) {
-    const artifactUrl = getArtifactUrl(artifacts, artifactName);
-    if (!artifactUrl) {
-      throw new Error(`artifact ${artifactName} not found`);
-    }
-    const auth = await this.resolveAuth({
-      collectionName
-    });
-    const options = {
-      params: {
-        collection: collectionName,
-        'max-age': FILE_CACHE_MAX_AGE
-      },
-      auth
-    };
-    return createUrl(`${auth.baseUrl}${artifactUrl}`, options);
-  }
-  async getImage(id, params, controller, fetchMaxRes, traceContext) {
-    // TODO add checkWebpSupport() back https://product-fabric.atlassian.net/browse/MPT-584
-    const isWebpSupported = false;
-    const headers = {};
-    if (isWebpSupported) {
-      headers.accept = 'image/webp,image/*,*/*;q=0.8';
-    }
-    const metadata = {
-      method: 'GET',
-      endpoint: '/file/{fileId}/image'
-    };
-    const options = {
-      ...metadata,
-      authContext: {
-        collectionName: params && params.collection
-      },
-      params: extendImageParams(params, fetchMaxRes),
-      headers,
-      traceContext
-    };
-    return this.request(`/file/${id}/image`, options, controller).then(createMapResponseToBlob(metadata));
-  }
-  async getItems(ids, collectionName, traceContext) {
-    const descriptors = ids.map(id => ({
-      type: 'file',
-      id,
-      collection: collectionName
-    }));
-    const metadata = {
-      method: 'POST',
-      endpoint: '/items'
-    };
-    const options = {
-      ...metadata,
-      authContext: {
-        collectionName
-      },
-      headers: jsonHeaders,
-      body: JSON.stringify({
-        descriptors
-      }),
-      traceContext
-    };
-    return this.request('/items', options).then(createMapResponseToJson(metadata));
-  }
-  async getImageMetadata(id, params, traceContext) {
-    const metadata = {
-      method: 'GET',
-      endpoint: '/file/{fileId}/image/metadata'
-    };
-    const options = {
-      ...metadata,
-      authContext: {
-        collectionName: params && params.collection
-      },
-      params,
-      traceContext
-    };
-    return this.request(`/file/${id}/image/metadata`, options).then(createMapResponseToJson(metadata));
-  }
-  async appendChunksToUpload(uploadId, body, collectionName, traceContext) {
-    const metadata = {
-      method: 'PUT',
-      endpoint: '/upload/{uploadId}/chunks'
-    };
-    const options = {
-      ...metadata,
-      authContext: {
-        collectionName
-      },
-      headers: jsonHeaders,
-      body: JSON.stringify(body),
-      traceContext
-    };
-    await this.request(`/upload/${uploadId}/chunks`, options);
-  }
-  copyFileWithToken(body, params, traceContext) {
-    const metadata = {
-      method: 'POST',
-      endpoint: '/file/copy/withToken'
-    };
-    const options = {
-      ...metadata,
-      authContext: {
-        collectionName: params.collection
-      },
-      // Contains collection name to write to
-      params,
-      // Contains collection name to write to
-      headers: jsonHeaders,
-      body: JSON.stringify(body),
-      // Contains collection name to read from
-      traceContext
-    };
-    return this.request('/file/copy/withToken', options).then(createMapResponseToJson(metadata));
-  }
-  async request(path, options = {
-    method: 'GET',
-    endpoint: undefined,
-    authContext: {}
-  }, controller) {
-    const {
-      method,
-      endpoint,
-      authContext,
-      params,
-      headers,
-      body,
-      clientOptions,
-      traceContext
-    } = options;
-    const auth = await this.resolveAuth(authContext);
-    const extendedTraceContext = traceContext ? {
-      ...traceContext,
-      spanId: (traceContext === null || traceContext === void 0 ? void 0 : traceContext.spanId) || getRandomHex(8)
-    } : undefined;
-    const response = await request(`${auth.baseUrl}${path}`, {
-      method,
-      endpoint,
-      auth,
-      params,
-      headers,
-      body,
-      clientOptions,
-      traceContext: extendedTraceContext
-    }, controller);
-    setKeyValueInSessionStorage(MEDIA_API_REGION, response.headers.get('x-media-region'));
-    setKeyValueInSessionStorage(MEDIA_API_ENVIRONMENT, response.headers.get('x-media-env'));
-    return response;
-  }
-}
-const getValueFromSessionStorage = key => {
-  return window && window.sessionStorage && window.sessionStorage.getItem(key) || undefined;
-};
-const setKeyValueInSessionStorage = (key, value) => {
-  if (!value || !(window && window.sessionStorage)) {
-    return;
-  }
-  const currentValue = window.sessionStorage.getItem(key);
-  if (currentValue !== value) {
-    window.sessionStorage.setItem(key, value);
-  }
-};
-export const getMediaEnvironment = () => {
-  return getValueFromSessionStorage(MEDIA_API_ENVIRONMENT);
-};
-export const getMediaRegion = () => {
-  return getValueFromSessionStorage(MEDIA_API_REGION);
-};
+export { MediaStore, getMediaEnvironment, getMediaRegion } from './MediaStore';

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

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