@atlaskit/media-client 14.0.0 → 14.3.0

package/dist/es2019/utils/mobileUpload/stateMachine/index.js

@@ -0,0 +1,52 @@
+import { map } from 'rxjs/operators/map';
+import { createMachine, interpret } from 'xstate';
+import { isProcessingFileState } from '../../../models/file-state';
+import { shouldFetchRemoteFileStates } from '../../shouldFetchRemoteFileStates';
+import { createMobileDownloadFileStream } from '../helpers';
+import { machineUploadingState } from './states/uploading';
+import { machineProcessingState } from './states/processing';
+import { machineProcessedState } from './states/processed';
+import { machineProcessingFailedState } from './states/processingFailed';
+import { machineErrorState } from './states/error';
+export const createMobileUploadStateMachine = (dataloader, initialState, collectionName) => createMachine({
+  // Initial state
+  initial: initialState.status,
+  // Context
+  context: {
+    currentFileState: initialState
+  },
+  // State definitions
+  states: {
+    uploading: machineUploadingState,
+    processing: machineProcessingState,
+    processed: machineProcessedState,
+    processingFailed: machineProcessingFailedState,
+    error: machineErrorState
+  }
+}, {
+  services: {
+    shouldFetchRemoteFileStates: async ctx => {
+      const {
+        currentFileState
+      } = ctx;
+
+      if (isProcessingFileState(currentFileState)) {
+        const {
+          mediaType,
+          mimeType,
+          preview
+        } = currentFileState;
+        return shouldFetchRemoteFileStates(mediaType, mimeType, preview);
+      }
+
+      return false;
+    },
+    fetchRemoteFileStates: ctx => createMobileDownloadFileStream(dataloader, ctx.currentFileState.id, collectionName, ctx.currentFileState.occurrenceKey).pipe(map(fileState => ({
+      type: 'REMOTE_FILESTATE_RESULT',
+      fileState
+    })))
+  }
+});
+export function createMobileUploadService(machine) {
+  return interpret(machine);
+}

package/dist/es2019/utils/mobileUpload/stateMachine/states/error.js

@@ -0,0 +1,3 @@
+export const machineErrorState = {
+  type: 'final'
+};

package/dist/es2019/utils/mobileUpload/stateMachine/states/processed.js

@@ -0,0 +1,3 @@
+export const machineProcessedState = {
+  type: 'final'
+};

package/dist/es2019/utils/mobileUpload/stateMachine/states/processing.js

@@ -0,0 +1,60 @@
+import { assign, send } from 'xstate';
+export const machineProcessingState = {
+  // Events
+  on: {
+    REMOTE_FILESTATE_PROCESSED: 'processed',
+    REMOTE_FILESTATE_PROCESSING_FAILED: 'processingFailed',
+    REMOTE_FILESTATE_ERROR: 'error'
+  },
+  // Initial sub state
+  initial: 'loading',
+  // Sub states definitions
+  states: {
+    loading: {
+      invoke: {
+        src: 'shouldFetchRemoteFileStates',
+        onDone: {
+          actions: send((_, event) => ({
+            // shouldFetchRemoteFileStates resolves a boolean
+            type: event.data ? 'REMOTE_FILESTATE_FETCH' : 'REMOTE_FILESTATE_BYPASS'
+          }))
+        },
+        onError: 'idle'
+      },
+      on: {
+        REMOTE_FILESTATE_FETCH: 'fetchingRemoteFileStates',
+        REMOTE_FILESTATE_BYPASS: 'idle'
+      }
+    },
+    fetchingRemoteFileStates: {
+      invoke: {
+        src: 'fetchRemoteFileStates',
+        onDone: {
+          actions: send(ctx => ({
+            type: ctx.currentFileState.status === 'processed' ? 'REMOTE_FILESTATE_PROCESSED' : 'REMOTE_FILESTATE_PROCESSING_FAILED'
+          }))
+        },
+        onError: {
+          actions: [assign({
+            currentFileState: (ctx, event) => ({
+              status: 'error',
+              id: ctx.currentFileState.id,
+              occurrenceKey: ctx.currentFileState.occurrenceKey,
+              message: event.data.message
+            })
+          }), send({
+            type: 'REMOTE_FILESTATE_ERROR'
+          })]
+        }
+      },
+      on: {
+        REMOTE_FILESTATE_RESULT: {
+          actions: assign({
+            currentFileState: (_, event) => event.fileState
+          })
+        }
+      }
+    },
+    idle: {}
+  }
+};

package/dist/es2019/utils/mobileUpload/stateMachine/states/processingFailed.js

@@ -0,0 +1,3 @@
+export const machineProcessingFailedState = {
+  type: 'final'
+};

package/dist/es2019/utils/mobileUpload/stateMachine/states/uploading.js

@@ -0,0 +1,44 @@
+import { assign } from 'xstate';
+import { isUploadingFileState } from '../../../../models/file-state';
+export const machineUploadingState = {
+  // Events
+  on: {
+    UPLOAD_PROGRESS: [{
+      target: 'uploading',
+      cond: (ctx, event) => isUploadingFileState(ctx.currentFileState) && event.progress > ctx.currentFileState.progress,
+      actions: assign({
+        currentFileState: (ctx, event) => ({ ...ctx.currentFileState,
+          progress: event.progress
+        })
+      })
+    }, {
+      target: 'error'
+    }],
+    UPLOAD_END: {
+      target: 'processing',
+      actions: assign({
+        currentFileState: ctx => isUploadingFileState(ctx.currentFileState) && {
+          status: 'processing',
+          id: ctx.currentFileState.id,
+          occurrenceKey: ctx.currentFileState.occurrenceKey,
+          name: ctx.currentFileState.name,
+          size: ctx.currentFileState.size,
+          mediaType: ctx.currentFileState.mediaType,
+          mimeType: ctx.currentFileState.mimeType,
+          preview: ctx.currentFileState.preview,
+          createdAt: ctx.currentFileState.createdAt
+        } || ctx.currentFileState
+      })
+    },
+    UPLOAD_ERROR: {
+      target: 'error',
+      actions: assign({
+        currentFileState: (ctx, event) => ({
+          status: 'error',
+          id: ctx.currentFileState.id,
+          message: event.message
+        })
+      })
+    }
+  }
+};

package/dist/es2019/utils/mobileUpload/stateMachine/types.js

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

package/dist/es2019/utils/polling/index.js

@@ -1,11 +1,11 @@
 import _defineProperty from "@babel/runtime/helpers/defineProperty";
-import { getMediaFeatureFlag } from '@atlaskit/media-common/mediaFeatureFlags';
 import { PollingError } from './errors';
+// default polling options without using feature flags
 export const defaultPollingOptions = {
-  poll_intervalMs: getMediaFeatureFlag('poll_intervalMs'),
-  poll_maxAttempts: getMediaFeatureFlag('poll_maxAttempts'),
-  poll_backoffFactor: getMediaFeatureFlag('poll_backoffFactor'),
-  poll_maxIntervalMs: getMediaFeatureFlag('poll_maxIntervalMs')
+  poll_intervalMs: 3000,
+  poll_maxAttempts: 30,
+  poll_backoffFactor: 1.25,
+  poll_maxIntervalMs: 200000
 };
 /**
  * This class encapsulates polling functionality with the following features:

package/dist/es2019/utils/setTimeoutPromise.js

@@ -0,0 +1,6 @@
+export const resolveTimeout = (timeout, resolveWith) => new Promise((resolve, _reject) => {
+  setTimeout(resolve, timeout, resolveWith);
+});
+export const rejectTimeout = (timeout, rejectWith) => new Promise((_resolve, reject) => {
+  setTimeout(reject, timeout, rejectWith);
+});

package/dist/es2019/version.json

@@ -1,5 +1,5 @@
 {
 	"name": "@atlaskit/media-client",
-	"version": "14.0.0",
+	"version": "14.3.0",
 	"sideEffects": false
 }

package/dist/esm/client/file-fetcher/index.js

@@ -12,7 +12,10 @@ import { Subscription } from 'rxjs/Subscription';
 import { of } from 'rxjs/observable/of';
 import { map } from 'rxjs/operators/map';
 import { concatMap } from 'rxjs/operators/concatMap';
-import uuid from 'uuid/v4';
+import uuid from 'uuid/v4'; // import setimmediate to temporary fix dataloader 2.0.0 bug
+// @see https://github.com/graphql/dataloader/issues/249
+
+import 'setimmediate';
 import { authToOwner } from '@atlaskit/media-core';
 import { downloadUrl } from '@atlaskit/media-common/downloadUrl';
 import { MediaStore } from '../media-store';
@@ -34,7 +37,6 @@ import { isMimeTypeSupportedByBrowser, getMediaTypeFromMimeType } from '@atlaski
 import { shouldFetchRemoteFileStates, shouldFetchRemoteFileStatesObservable } from '../../utils/shouldFetchRemoteFileStates';
 import { PollingFunction } from '../../utils/polling';
 import { isEmptyFile } from '../../utils/detectEmptyFile';
-import { getMediaFeatureFlag } from '@atlaskit/media-common/mediaFeatureFlags';
 export { isFileFetcherError, FileFetcherError } from './error';
 export var FileFetcherImpl = /*#__PURE__*/function () {
   function FileFetcherImpl(mediaStore) {
@@ -44,14 +46,7 @@ export var FileFetcherImpl = /*#__PURE__*/function () {
 
     _defineProperty(this, "createDownloadFileStream", function (id, collectionName, occurrenceKey) {
       var subject = createFileStateSubject();
-      var featureFlags = _this.mediaStore.featureFlags;
-      var pollingOptions = {
-        poll_intervalMs: getMediaFeatureFlag('poll_intervalMs', featureFlags),
-        poll_maxAttempts: getMediaFeatureFlag('poll_maxAttempts', featureFlags),
-        poll_backoffFactor: getMediaFeatureFlag('poll_backoffFactor', featureFlags),
-        poll_maxIntervalMs: getMediaFeatureFlag('poll_maxIntervalMs', featureFlags)
-      };
-      var poll = new PollingFunction(pollingOptions); // ensure subject errors if polling exceeds max iterations or uncaught exception in executor
+      var poll = new PollingFunction(); // ensure subject errors if polling exceeds max iterations or uncaught exception in executor
 
       poll.onError = function (error) {
         return subject.error(error);

package/dist/esm/client/media-client.js

@@ -8,6 +8,7 @@ import { CollectionFetcher } from './collection-fetcher';
 import { FileFetcherImpl } from './file-fetcher';
 import { StargateClient } from './stargate-client';
 export var MediaClient = /*#__PURE__*/function () {
+  // mobile upload is lazily loaded
   // Deprecated value introduced for backward compatibility with Context
   function MediaClient(mediaClientConfig, featureFlags) {
     _classCallCheck(this, MediaClient);
@@ -67,6 +68,47 @@ export var MediaClient = /*#__PURE__*/function () {
 
       return getImageMetadata;
     }()
+  }, {
+    key: "mobileUploadPromise",
+    value: function () {
+      var _mobileUploadPromise = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee2() {
+        var module;
+        return _regeneratorRuntime.wrap(function _callee2$(_context2) {
+          while (1) {
+            switch (_context2.prev = _context2.next) {
+              case 0:
+                if (!this.mobileUpload) {
+                  _context2.next = 2;
+                  break;
+                }
+
+                return _context2.abrupt("return", this.mobileUpload);
+
+              case 2:
+                _context2.next = 4;
+                return import(
+                /* webpackChunkName: "@atlaskit-internal_media-client-mobile-upload" */
+                './mobile-upload');
+
+              case 4:
+                module = _context2.sent;
+                this.mobileUpload = new module.MobileUploadImpl(this.mediaStore);
+                return _context2.abrupt("return", this.mobileUpload);
+
+              case 7:
+              case "end":
+                return _context2.stop();
+            }
+          }
+        }, _callee2, this);
+      }));
+
+      function mobileUploadPromise() {
+        return _mobileUploadPromise.apply(this, arguments);
+      }
+
+      return mobileUploadPromise;
+    }()
   }, {
     key: "on",
     value: function on(event, listener) {

package/dist/esm/client/media-store/resolveAuth.js

@@ -1,38 +1,58 @@
 import _regeneratorRuntime from "@babel/runtime/regenerator";
 import _asyncToGenerator from "@babel/runtime/helpers/asyncToGenerator";
 import { MediaStoreError } from './error';
-export var TOKEN_MINIMUM_LIFETIME = 10000; // 10 sec
-
+import { rejectTimeout } from '../../utils/setTimeoutPromise';
+export var DEFAULT_AUTH_PROVIDER_TIMEOUT = 10000;
 export var resolveAuth = /*#__PURE__*/function () {
   var _ref = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee(authProvider, authContext) {
-    var auth;
+    var authProviderTimeout,
+        auth,
+        _args = arguments;
     return _regeneratorRuntime.wrap(function _callee$(_context) {
       while (1) {
         switch (_context.prev = _context.next) {
           case 0:
-            _context.prev = 0;
-            _context.next = 3;
-            return authProvider(authContext);
+            authProviderTimeout = _args.length > 2 && _args[2] !== undefined ? _args[2] : DEFAULT_AUTH_PROVIDER_TIMEOUT;
+            _context.prev = 1;
+            _context.next = 4;
+            return Promise.race([authProvider(authContext), rejectTimeout(authProviderTimeout, new MediaStoreError('authProviderTimedOut'))]);
 
-          case 3:
+          case 4:
             auth = _context.sent;
-            _context.next = 9;
+            _context.next = 12;
             break;
 
-          case 6:
-            _context.prev = 6;
-            _context.t0 = _context["catch"](0);
+          case 7:
+            _context.prev = 7;
+            _context.t0 = _context["catch"](1);
+
+            if (!(_context.t0 instanceof MediaStoreError)) {
+              _context.next = 11;
+              break;
+            }
+
+            throw _context.t0;
+
+          case 11:
             throw new MediaStoreError('failedAuthProvider', _context.t0);
 
-          case 9:
+          case 12:
+            if (auth) {
+              _context.next = 14;
+              break;
+            }
+
+            throw new MediaStoreError('emptyAuth');
+
+          case 14:
             return _context.abrupt("return", auth);
 
-          case 10:
+          case 15:
           case "end":
             return _context.stop();
         }
       }
-    }, _callee, null, [[0, 6]]);
+    }, _callee, null, [[1, 7]]);
   }));
 
   return function resolveAuth(_x, _x2) {

package/dist/esm/client/mobile-upload.js

@@ -0,0 +1,83 @@
+import _classCallCheck from "@babel/runtime/helpers/classCallCheck";
+import _createClass from "@babel/runtime/helpers/createClass";
+import { getMediaTypeFromMimeType } from '@atlaskit/media-common';
+import { getFileStreamsCache } from '../file-streams-cache';
+import { createFileDataloader } from '../utils/createFileDataLoader';
+import { createServicesCache, createMobileUploadStateMachine, createMobileUploadService, createMobileFileStateSubject } from '../utils/mobileUpload';
+export var MobileUploadImpl = /*#__PURE__*/function () {
+  function MobileUploadImpl(mediaStore) {
+    _classCallCheck(this, MobileUploadImpl);
+
+    this.dataloader = createFileDataloader(mediaStore);
+    this.servicesCache = createServicesCache();
+  }
+
+  _createClass(MobileUploadImpl, [{
+    key: "notifyUploadStart",
+    value: function notifyUploadStart(event) {
+      var fileId = event.fileId,
+          collectionName = event.collectionName,
+          occurrenceKey = event.occurrenceKey,
+          fileName = event.fileName,
+          fileSize = event.fileSize,
+          fileMimetype = event.fileMimetype,
+          preview = event.preview,
+          createdAt = event.createdAt;
+      var mediaType = getMediaTypeFromMimeType(fileMimetype);
+      var initialState = {
+        status: 'uploading',
+        id: fileId,
+        occurrenceKey: occurrenceKey,
+        name: fileName,
+        size: fileSize,
+        progress: 0,
+        mediaType: mediaType,
+        mimeType: fileMimetype,
+        preview: preview,
+        createdAt: createdAt
+      };
+      var service = createMobileUploadService(createMobileUploadStateMachine(this.dataloader, initialState, collectionName));
+      var subject = createMobileFileStateSubject(service);
+      this.servicesCache.put(fileId, service);
+      getFileStreamsCache().set(fileId, subject);
+    }
+  }, {
+    key: "notifyUploadProgress",
+    value: function notifyUploadProgress(event) {
+      var fileId = event.fileId,
+          progress = event.progress;
+      var service = this.servicesCache.get(fileId);
+
+      if (service) {
+        service.send('UPLOAD_PROGRESS', {
+          progress: progress
+        });
+      }
+    }
+  }, {
+    key: "notifyUploadEnd",
+    value: function notifyUploadEnd(event) {
+      var fileId = event.fileId;
+      var service = this.servicesCache.get(fileId);
+
+      if (service) {
+        service.send('UPLOAD_END');
+      }
+    }
+  }, {
+    key: "notifyUploadError",
+    value: function notifyUploadError(event) {
+      var fileId = event.fileId,
+          message = event.message;
+      var service = this.servicesCache.get(fileId);
+
+      if (service) {
+        service.send('UPLOAD_ERROR', {
+          message: message
+        });
+      }
+    }
+  }]);
+
+  return MobileUploadImpl;
+}();

package/dist/esm/index.js

@@ -10,6 +10,7 @@ export { request, RequestError, isRequestError, isRateLimitedError } from './uti
 export { isAbortedRequestError, mapResponseToJson, mapResponseToBlob, mapResponseToVoid, createUrl } from './utils/request/helpers';
 export { PollingFunction } from './utils/polling';
 export { isPollingError, PollingError } from './utils/polling/errors';
+export { imageResizeModeToFileImageMode } from './utils/imageResizeModeToFileImageMode';
 export { FileFetcherImpl, FileFetcherError, isFileFetcherError } from './client/file-fetcher';
 export { CollectionFetcher } from './client/collection-fetcher';
 export { MediaClient } from './client/media-client';

package/dist/esm/models/mobile-upload.js

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

package/dist/esm/utils/createFileDataLoader.js

@@ -1,6 +1,9 @@
 import _regeneratorRuntime from "@babel/runtime/regenerator";
 import _toConsumableArray from "@babel/runtime/helpers/toConsumableArray";
 import _asyncToGenerator from "@babel/runtime/helpers/asyncToGenerator";
+// import setimmediate to temporary fix dataloader 2.0.0 bug
+// @see https://github.com/graphql/dataloader/issues/249
+import 'setimmediate';
 import Dataloader from 'dataloader';
 export var MAX_BATCH_SIZE = 100;
 

package/dist/esm/utils/imageResizeModeToFileImageMode.js

@@ -0,0 +1,3 @@
+export var imageResizeModeToFileImageMode = function imageResizeModeToFileImageMode(resizeMode) {
+  return resizeMode === 'stretchy-fit' ? 'full-fit' : resizeMode;
+};

package/dist/esm/utils/mobileUpload/error.js

@@ -0,0 +1,51 @@
+import _classCallCheck from "@babel/runtime/helpers/classCallCheck";
+import _createClass from "@babel/runtime/helpers/createClass";
+import _inherits from "@babel/runtime/helpers/inherits";
+import _possibleConstructorReturn from "@babel/runtime/helpers/possibleConstructorReturn";
+import _getPrototypeOf from "@babel/runtime/helpers/getPrototypeOf";
+
+function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
+
+function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
+
+import { BaseMediaClientError } from '../../models/errors';
+export var MobileUploadError = /*#__PURE__*/function (_BaseMediaClientError) {
+  _inherits(MobileUploadError, _BaseMediaClientError);
+
+  var _super = _createSuper(MobileUploadError);
+
+  function MobileUploadError(reason, id, metadata) {
+    var _this;
+
+    _classCallCheck(this, MobileUploadError);
+
+    _this = _super.call(this, reason);
+    _this.reason = reason;
+    _this.id = id;
+    _this.metadata = metadata;
+    return _this;
+  }
+
+  _createClass(MobileUploadError, [{
+    key: "attributes",
+    get: function get() {
+      var reason = this.reason,
+          id = this.id,
+          _this$metadata = this.metadata;
+      _this$metadata = _this$metadata === void 0 ? {} : _this$metadata;
+      var collectionName = _this$metadata.collectionName,
+          occurrenceKey = _this$metadata.occurrenceKey;
+      return {
+        reason: reason,
+        id: id,
+        collectionName: collectionName,
+        occurrenceKey: occurrenceKey
+      };
+    }
+  }]);
+
+  return MobileUploadError;
+}(BaseMediaClientError);
+export function isMobileUploadError(err) {
+  return err instanceof MobileUploadError;
+}

package/dist/esm/utils/mobileUpload/helpers.js

@@ -0,0 +1,86 @@
+import _regeneratorRuntime from "@babel/runtime/regenerator";
+import _asyncToGenerator from "@babel/runtime/helpers/asyncToGenerator";
+import { ReplaySubject } from 'rxjs/ReplaySubject';
+import { from } from 'rxjs/observable/from';
+import { map } from 'rxjs/operators/map';
+import { mapMediaItemToFileState } from '../../models/file-state';
+import { createFileStateSubject } from '../createFileStateSubject';
+import { isEmptyFile } from '../detectEmptyFile';
+import { PollingFunction } from '../polling';
+import { MobileUploadError } from './error';
+export var createMobileFileStateSubject = function createMobileFileStateSubject(service) {
+  var subject = new ReplaySubject(1);
+  from(service.start()).pipe(map(function (state) {
+    return state.context.currentFileState;
+  })).subscribe(subject);
+  return subject;
+};
+export var createMobileDownloadFileStream = function createMobileDownloadFileStream(dataloader, id, collectionName, occurrenceKey) {
+  var subject = createFileStateSubject();
+  var poll = new PollingFunction(); // ensure subject errors if polling exceeds max iterations or uncaught exception in executor
+
+  poll.onError = function (error) {
+    return subject.error(error);
+  };
+
+  poll.execute( /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee() {
+    var response, fileState;
+    return _regeneratorRuntime.wrap(function _callee$(_context) {
+      while (1) {
+        switch (_context.prev = _context.next) {
+          case 0:
+            _context.next = 2;
+            return dataloader.load({
+              id: id,
+              collectionName: collectionName
+            });
+
+          case 2:
+            response = _context.sent;
+
+            if (response) {
+              _context.next = 5;
+              break;
+            }
+
+            throw new MobileUploadError('emptyItems', id, {
+              collectionName: collectionName,
+              occurrenceKey: occurrenceKey
+            });
+
+          case 5:
+            if (!isEmptyFile(response)) {
+              _context.next = 7;
+              break;
+            }
+
+            throw new MobileUploadError('zeroVersionFile', id, {
+              collectionName: collectionName,
+              occurrenceKey: occurrenceKey
+            });
+
+          case 7:
+            fileState = mapMediaItemToFileState(id, response);
+            subject.next(fileState);
+            _context.t0 = fileState.status;
+            _context.next = _context.t0 === 'processing' ? 12 : _context.t0 === 'processed' ? 14 : 16;
+            break;
+
+          case 12:
+            // the only case for continuing polling, otherwise this function is run once only
+            poll.next();
+            return _context.abrupt("break", 16);
+
+          case 14:
+            subject.complete();
+            return _context.abrupt("break", 16);
+
+          case 16:
+          case "end":
+            return _context.stop();
+        }
+      }
+    }, _callee);
+  })));
+  return subject;
+};

package/dist/esm/utils/mobileUpload/index.js

@@ -0,0 +1,4 @@
+export { isMobileUploadError, MobileUploadError } from './error';
+export { createServicesCache } from './servicesCache';
+export { createMobileUploadService, createMobileUploadStateMachine } from './stateMachine';
+export { createMobileFileStateSubject } from './helpers';

package/dist/esm/utils/mobileUpload/servicesCache.js

@@ -0,0 +1,4 @@
+import { LRUCache } from 'lru-fast';
+export function createServicesCache() {
+  return new LRUCache(100);
+}