@atlaskit/media-client 25.0.3 → 26.0.0

package/CHANGELOG.md

@@ -1,5 +1,23 @@
 # @atlaskit/media-client
 
+## 26.0.0
+
+### Major Changes
+
+- [#60352](https://stash.atlassian.com/projects/CONFCLOUD/repos/confluence-frontend/pull-requests/60352) [`ff9488b450dd`](https://stash.atlassian.com/projects/CONFCLOUD/repos/confluence-frontend/commits/ff9488b450dd) - WHAT: Media has removed the ability to probe for existing file chunks.  
+  WHY: This is to support the work to deprecate SHA1 usage and make the Media Platform comply with FedRAMP moderate controls.
+  HOW: Remove any calls you have directly to probing, instead upload all files directly. If you upload files via MediaPicker no changes are required.
+
+### Patch Changes
+
+- Updated dependencies
+
+## 25.1.0
+
+### Minor Changes
+
+- [#43817](https://bitbucket.org/atlassian/atlassian-frontend/pull-requests/43817) [`048aca70499`](https://bitbucket.org/atlassian/atlassian-frontend/commits/048aca70499) - new Mocked Media Api utility for tests
+
 ## 25.0.3
 
 ### Patch Changes

package/dist/cjs/client/media-store/MediaStore.js

@@ -154,28 +154,6 @@ var MediaStore = exports.MediaStore = /*#__PURE__*/function () {
       }
       return uploadChunk;
     }()
-  }, {
-    key: "probeChunks",
-    value: function probeChunks(chunks, uploadId, collectionName, traceContext) {
-      var metadata = {
-        method: 'POST',
-        endpoint: '/chunk/probe'
-      };
-      var options = _objectSpread(_objectSpread({}, metadata), {}, {
-        params: {
-          uploadId: uploadId
-        },
-        authContext: {
-          collectionName: collectionName
-        },
-        headers: jsonHeaders,
-        body: JSON.stringify({
-          chunks: chunks
-        }),
-        traceContext: traceContext
-      });
-      return this.request("/chunk/probe", options).then((0, _helpers.createMapResponseToJson)(metadata));
-    }
   }, {
     key: "createFileFromUpload",
     value: function createFileFromUpload(body) {

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

@@ -0,0 +1,432 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createMockedMediaApi = void 0;
+var _regenerator = _interopRequireDefault(require("@babel/runtime/regenerator"));
+var _asyncToGenerator2 = _interopRequireDefault(require("@babel/runtime/helpers/asyncToGenerator"));
+var _helpers = require("./helpers");
+var getMediaApi = function getMediaApi(_ref) {
+  var getFileItem = _ref.getFileItem;
+  return {
+    // --------------------------------------------------------
+    // UPLOAD ENDPOINTS - None is supported
+    // --------------------------------------------------------
+
+    touchFiles: function () {
+      var _touchFiles = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee(_ref2) {
+        var descriptors;
+        return _regenerator.default.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 = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee2(_etag, _blob, uploadId) {
+        return _regenerator.default.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 = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee3() {
+        return _regenerator.default.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 = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee4(_ref3, _ref4) {
+        var uploadId, collection;
+        return _regenerator.default.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 = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee5() {
+        return _regenerator.default.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 = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee6(fileId) {
+        var fileItem;
+        return _regenerator.default.wrap(function _callee6$(_context6) {
+          while (1) switch (_context6.prev = _context6.next) {
+            case 0:
+              fileItem = getFileItem(fileId);
+              if (fileItem) {
+                _context6.next = 3;
+                break;
+              }
+              throw new Error('404 - MockedMediaApi.getFile: file not found');
+            case 3:
+              return _context6.abrupt("return", {
+                data: (0, _helpers.getMediaFile)(fileItem)
+              });
+            case 4:
+            case "end":
+              return _context6.stop();
+          }
+        }, _callee6);
+      }));
+      function getFile(_x7) {
+        return _getFile.apply(this, arguments);
+      }
+      return getFile;
+    }(),
+    getItems: function () {
+      var _getItems = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee7(ids) {
+        var items;
+        return _regenerator.default.wrap(function _callee7$(_context7) {
+          while (1) switch (_context7.prev = _context7.next) {
+            case 0:
+              items = ids.map(function (id) {
+                return getFileItem(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 = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee8() {
+        return _regenerator.default.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
+    // --------------------------------------------------------
+
+    // TODO
+    getFileImageURL: function () {
+      var _getFileImageURL = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee9() {
+        return _regenerator.default.wrap(function _callee9$(_context9) {
+          while (1) switch (_context9.prev = _context9.next) {
+            case 0:
+              throw new Error('500 - MockedMediaApi.getFileImageURL: method not implemented');
+            case 1:
+            case "end":
+              return _context9.stop();
+          }
+        }, _callee9);
+      }));
+      function getFileImageURL() {
+        return _getFileImageURL.apply(this, arguments);
+      }
+      return getFileImageURL;
+    }(),
+    // TODO
+    getFileImageURLSync: function getFileImageURLSync() {
+      throw new Error('500 - MockedMediaApi.getFileImageURLSync: method not implemented');
+    },
+    getFileBinaryURL: function () {
+      var _getFileBinaryURL = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee10(id) {
+        var fileItem;
+        return _regenerator.default.wrap(function _callee10$(_context10) {
+          while (1) switch (_context10.prev = _context10.next) {
+            case 0:
+              fileItem = getFileItem(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(_x9) {
+        return _getFileBinaryURL.apply(this, arguments);
+      }
+      return getFileBinaryURL;
+    }(),
+    getArtifactURL: function () {
+      var _getArtifactURL = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee11(artifacts, artifactName) {
+        var _artifacts$artifactNa;
+        var artifactUrl;
+        return _regenerator.default.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(_x10, _x11) {
+        return _getArtifactURL.apply(this, arguments);
+      }
+      return getArtifactURL;
+    }(),
+    // --------------------------------------------------------
+    // BINARY ENDPOINTS
+    // --------------------------------------------------------
+    getImage: function () {
+      var _getImage = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee12(fileId) {
+        var fileItem;
+        return _regenerator.default.wrap(function _callee12$(_context12) {
+          while (1) switch (_context12.prev = _context12.next) {
+            case 0:
+              fileItem = getFileItem(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(_x12) {
+        return _getImage.apply(this, arguments);
+      }
+      return getImage;
+    }(),
+    // --------------------------------------------------------
+    // OTHER ENDPOINTS
+    // --------------------------------------------------------
+
+    // TODO
+    copyFileWithToken: function () {
+      var _copyFileWithToken = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee13(body) {
+        var fileId, fileItem;
+        return _regenerator.default.wrap(function _callee13$(_context13) {
+          while (1) switch (_context13.prev = _context13.next) {
+            case 0:
+              fileId = body.sourceFile.id;
+              fileItem = getFileItem(fileId);
+              if (fileItem) {
+                _context13.next = 4;
+                break;
+              }
+              throw new Error('404 - MockedMediaApi.copyFileWithToken: file not found');
+            case 4:
+              return _context13.abrupt("return", {
+                data: (0, _helpers.getMediaFile)(fileItem)
+              });
+            case 5:
+            case "end":
+              return _context13.stop();
+          }
+        }, _callee13);
+      }));
+      function copyFileWithToken(_x13) {
+        return _copyFileWithToken.apply(this, arguments);
+      }
+      return copyFileWithToken;
+    }(),
+    // TODO
+    removeCollectionFile: function () {
+      var _removeCollectionFile = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee14() {
+        return _regenerator.default.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 = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee15() {
+        return _regenerator.default.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 = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee16() {
+        return _regenerator.default.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
+ */
+var createMockedMediaApi = exports.createMockedMediaApi = function createMockedMediaApi(initialFileItems) {
+  var storedFileItems = new Map();
+  var getFileItem = function getFileItem(fileId) {
+    return storedFileItems.get(fileId);
+  };
+  var setFileItems = function setFileItems(fileItems) {
+    var normalised = (0, _helpers.normaliseInput)(fileItems);
+    normalised.forEach(function (fileItem) {
+      return storedFileItems.set(fileItem.id, fileItem);
+    });
+  };
+  if (initialFileItems) {
+    setFileItems(initialFileItems);
+  }
+  var mediaApi = getMediaApi({
+    setFileItems: setFileItems,
+    getFileItem: getFileItem
+  });
+  return {
+    setFileItems: setFileItems,
+    getFileItem: getFileItem,
+    mediaApi: mediaApi
+  };
+};

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

@@ -0,0 +1,184 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.normaliseInput = exports.getMediaFile = exports.getIdentifier = exports.createUploadingFileState = exports.createProcessingFileItem = exports.createFileState = exports.createErrorFileState = exports.createEmptyFileItem = exports.copy = void 0;
+var _slicedToArray2 = _interopRequireDefault(require("@babel/runtime/helpers/slicedToArray"));
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+var _v = _interopRequireDefault(require("uuid/v4"));
+function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
+function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { (0, _defineProperty2.default)(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
+// --------------------------------------------------------
+// Factory Utils
+// --------------------------------------------------------
+
+var normaliseInput = exports.normaliseInput = function normaliseInput(input) {
+  return !input ? [] : input instanceof Array ? input : [input];
+};
+
+// --------------------------------------------------------
+// Utils for the main class
+// --------------------------------------------------------
+
+var getMediaFile = exports.getMediaFile = function getMediaFile(fileItem) {
+  return _objectSpread({
+    id: fileItem.id
+  }, fileItem.details);
+};
+
+// --------------------------------------------------------
+// Utils for creating file descriptors for tests
+// --------------------------------------------------------
+
+var createEmptyFileItem = exports.createEmptyFileItem = function createEmptyFileItem(id, collection) {
+  var emptyFileItem = {
+    type: 'file',
+    id: 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
+ */
+var createProcessingFileItem = exports.createProcessingFileItem = function 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 _objectSpread(_objectSpread({}, fileItem), {}, {
+      details: _objectSpread(_objectSpread({}, fileItem.details), {}, {
+        processingStatus: 'pending',
+        artifacts: {},
+        // The preview will only be ready at 100% -> TODO verify against backend
+        representations: {}
+      })
+    });
+  }
+  var artifactsKeys = Object.keys(fileItem.details.artifacts);
+  var artifactsEntries = Object.entries(_objectSpread({}, fileItem.details.artifacts));
+
+  // Get a % of the total artifacts to be set as processed
+  var processedArtifactKeys = artifactsKeys.slice(0, Math.ceil(artifactsKeys.length * percent));
+  var processedArtifactEntries = artifactsEntries.map(function (_ref) {
+    var _ref2 = (0, _slicedToArray2.default)(_ref, 2),
+      key = _ref2[0],
+      artifact = _ref2[1];
+    return [key, _objectSpread(_objectSpread({}, artifact), {}, {
+      processingStatus: processedArtifactKeys.includes(key) ? 'succeeded' : 'pending'
+    })];
+  });
+  var artifactsProcessingPercent = Object.fromEntries(processedArtifactEntries);
+  return _objectSpread(_objectSpread({}, fileItem), {}, {
+    details: _objectSpread(_objectSpread({}, 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
+ * */
+var copy = exports.copy = function copy(fileItem) {
+  return JSON.parse(JSON.stringify(fileItem).replace(new RegExp(fileItem.id, 'g'), (0, _v.default)()));
+};
+/**
+ * Extracts the file identifier from the provided file item
+ */
+var getIdentifier = exports.getIdentifier = function getIdentifier(fileItem) {
+  return {
+    mediaItemType: 'file',
+    id: fileItem.id,
+    collectionName: fileItem.collection
+  };
+};
+var createFileState = exports.createFileState = function createFileState(_ref3) {
+  var id = _ref3.id,
+    _ref3$details = _ref3.details,
+    name = _ref3$details.name,
+    size = _ref3$details.size,
+    mediaType = _ref3$details.mediaType,
+    mimeType = _ref3$details.mimeType,
+    createdAt = _ref3$details.createdAt,
+    processingStatus = _ref3$details.processingStatus,
+    artifacts = _ref3$details.artifacts,
+    representations = _ref3$details.representations;
+  return {
+    status: processingStatus === 'succeeded' ? 'processed' : 'processing',
+    id: id,
+    name: name,
+    size: size,
+    mediaType: mediaType,
+    mimeType: mimeType,
+    createdAt: createdAt,
+    artifacts: artifacts,
+    representations: representations
+  };
+};
+var createUploadingFileState = exports.createUploadingFileState = function createUploadingFileState(_ref4, progress) {
+  var id = _ref4.id,
+    _ref4$details = _ref4.details,
+    name = _ref4$details.name,
+    size = _ref4$details.size,
+    mediaType = _ref4$details.mediaType,
+    mimeType = _ref4$details.mimeType,
+    createdAt = _ref4$details.createdAt;
+  return {
+    status: 'uploading',
+    progress: progress,
+    id: id,
+    name: name,
+    size: size,
+    mediaType: mediaType,
+    mimeType: mimeType,
+    createdAt: createdAt,
+    preview: {
+      value: new Blob(['some-content'], {
+        type: mimeType
+      })
+    }
+  };
+};
+var createErrorFileState = exports.createErrorFileState = function createErrorFileState(_ref5) {
+  var id = _ref5.id;
+  return {
+    status: 'error',
+    id: id,
+    reason: 'a random error',
+    message: 'a random error message',
+    details: {
+      some: 'mocked error detail'
+    }
+  };
+};