@jpmorganchase/mosaic-core 0.1.0-beta.3

package/.turbo/turbo-build.log

@@ -0,0 +1,2 @@
+@jpmorganchase/mosaic-core:build: cache hit, replaying output 51fa83327ed9be55
+@jpmorganchase/mosaic-core:build: $ tsc

package/.turbo/turbo-clean.log

@@ -0,0 +1,2 @@
+@jpmorganchase/mosaic-core:clean: cache hit, replaying output bc081733e7257886
+@jpmorganchase/mosaic-core:clean: $ rm -fr dist

package/CHANGELOG.md

@@ -0,0 +1,34 @@
+# @jpmorganchase/mosaic-core
+
+## 0.1.0-beta.3
+
+### Patch Changes
+
+- 457df5e: switch to public package
+- Updated dependencies [457df5e]
+  - @jpmorganchase/mosaic-types@0.1.0-beta.3
+
+## 0.1.0-beta.2
+
+### Patch Changes
+
+- e1bbbe7: Initial release of Mosaic Core file-system.
+
+  Mosaic is a content aggregating service which pulls content from heterogeneous data sources.
+
+- 4b2bc51: pipped to 0.1.0-beta.1 for publishing to NPM
+- Updated dependencies [e1bbbe7]
+- Updated dependencies [4b2bc51]
+  - @jpmorganchase/mosaic-types@0.1.0-beta.2
+
+## 0.1.0
+
+### Patch Changes
+
+- e1bbbe7: Initial release of Mosaic Core file-system.
+
+  Mosaic is a content aggregating service which pulls content from heterogeneous data sources.
+
+- Updated dependencies [e1bbbe7]
+- Updated dependencies [bbc853c]
+  - @jpmorganchase/mosaic-types@0.1.0

package/package.json

@@ -0,0 +1,36 @@
+{
+  "name": "@jpmorganchase/mosaic-core",
+  "version": "0.1.0-beta.3",
+  "author": "",
+  "description": "",
+  "license": "Apache-2.0",
+  "main": "./dist/index.js",
+  "engines": {
+    "node": ">= 12.0.0"
+  },
+  "scripts": {
+    "build": "tsc",
+    "clean": "rm -fr dist",
+    "start": "node --trace-warnings ./dist/example",
+    "start:debug": "node --inspect-brk ./dist/example"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git@github.com:jpmorganchase/mosaic.git"
+  },
+  "devDependencies": {
+    "express": "^4.17.1",
+    "cors": "^2.8.5",
+    "@types/express": "^4.17.13"
+  },
+  "dependencies": {
+    "gray-matter": "^4.0.3",
+    "@jpmorganchase/mosaic-types": "^0.1.0-beta.3",
+    "md5": "*",
+    "unionfs": "^4.4.0",
+    "lodash": "^4.17.21",
+    "fast-glob": "*",
+    "memfs": "^3.3.0",
+    "rxjs": "^7.5.5"
+  }
+}

package/src/PluginError.ts

@@ -0,0 +1,3 @@
+export default class PluginError extends Error {
+    
+}

package/src/PullDocs.ts

@@ -0,0 +1,124 @@
+import type { IUnionFs } from 'unionfs';
+import { Union } from 'unionfs';
+import type { IFS } from 'unionfs/lib/fs';
+
+import type PluginModuleDefinition from '@jpmorganchase/mosaic-types/dist/PluginModuleDefinition';
+import type SerialiserModuleDefinition from '@jpmorganchase/mosaic-types/dist/SerialiserModuleDefinition';
+import type SourceModuleDefinition from '@jpmorganchase/mosaic-types/dist/SourceModuleDefinition';
+
+import SourceManager from './SourceManager';
+
+// TODO:
+// Remove $ref /index resolution
+import MutableVolume from './filesystems/MutableVolume';
+import UnionFileAccess from './filesystems/UnionFileAccess';
+import UnionVolume from './filesystems/UnionVolume';
+import { Volume } from 'memfs';
+import FileAccess from './filesystems/FileAccess';
+
+export default class PullDocs {
+  #sourceDefinitions: SourceModuleDefinition[];
+  #sourceManager: SourceManager;
+  #ufs = new Union() as IUnionFs & { fss: MutableVolume[] };
+  #vfs: UnionVolume;
+
+  /**
+   *
+   * @param config.sources Sources are observables that emit pages
+   * @param config.plugins Plugins are modules with lifecycles methods for manipulating files and/or the virtual filesystem
+   * @param config.serialisers  Serialisers are a form of plugin that tell PullDocs how to turn a file from/to a storable form for the filesystem - or back into a `Page` object
+   * @param config.ignorePages Page names to exclude from lazy loading / `$ref`s / `$tag`s / serialisers and also any plugins that expect pages as input. Example input would be "ignore-me.xml"
+   * @param config.pageExtensions Exts of files to treat as pages. Pages contain metadata and content, in any file format (as long as a serialiser exists to encode/decode them). They can be referenced via `$ref`s / `$tag`s and also support lazy loading
+   */
+  constructor(config: {
+    ignorePages?: string[];
+    plugins?: PluginModuleDefinition[];
+    serialisers?: SerialiserModuleDefinition[];
+    sources: SourceModuleDefinition[];
+    pageExtensions: string[];
+  }) {
+    const sharedFilesystem = new MutableVolume(new FileAccess(new Volume()), '*');
+    this.#ufs.use(sharedFilesystem as unknown as any);
+    const {
+      ignorePages = [],
+      sources = [],
+      plugins = [],
+      serialisers = [],
+      pageExtensions = ['.mdx']
+    } = config;
+    this.#sourceDefinitions = sources;
+    this.#vfs = new UnionVolume(new UnionFileAccess(this.#ufs), '*');
+    this.#sourceManager = new SourceManager(
+      // Refs and aliases should be applied after all other plugins, so we add them manually with a negative priority
+      plugins
+        .concat(
+          {
+            modulePath: require.resolve('@jpmorganchase/mosaic-plugins/dist/$TagPlugin'),
+            options: {}
+          },
+          {
+            modulePath: require.resolve('@jpmorganchase/mosaic-plugins/dist/$CodeModPlugin'),
+            options: {},
+            // Make sure this happens as the very first plugin, so it can fix any page issues
+            priority: Number.POSITIVE_INFINITY
+          },
+          {
+            modulePath: require.resolve('@jpmorganchase/mosaic-plugins/dist/$AliasPlugin'),
+            options: {},
+            priority: -1
+          },
+          {
+            modulePath: require.resolve('@jpmorganchase/mosaic-plugins/dist/$RefPlugin'),
+            options: {},
+            priority: -1
+          }
+        )
+        .sort(({ priority: priorityA = 0 }, { priority: priorityB = 0 }) => priorityB - priorityA),
+      // Auto add JSON serialiser
+      serialisers.concat({
+        modulePath: require.resolve('@jpmorganchase/mosaic-serialisers/dist/json'),
+        filter: /\.json$/,
+        options: {}
+      }),
+      pageExtensions,
+      ignorePages,
+      this.#vfs,
+      sharedFilesystem
+    );
+  }
+
+  get filesystem() {
+    return this.#vfs;
+  }
+
+  onSourceUpdate(callback) {
+    return this.#sourceManager.onSourceUpdate(callback);
+  }
+
+  async start() {
+    return Promise.all(this.#sourceDefinitions.map(source => this.#addSource(source)));
+  }
+
+  async stop() {
+    return this.#sourceManager.destroyAll();
+  }
+
+  async #addSource(sourceDefinition) {
+    const source = await this.#sourceManager.addSource(sourceDefinition, {});
+    source.onError(error => {
+      console.error(new Error(`Source '${source.id.description}' threw an exception. See below:`));
+      console.error(error);
+    });
+    source.onExit(() => {
+      this.#ufs.fss.splice(this.#ufs.fss.indexOf(source.filesystem), 1);
+
+      if (this.#ufs.fss.length < 1) {
+        console.debug("[PullDocs] All of my source have been terminated. That's sad :-(");
+      }
+    });
+
+    this.#ufs.use(source.filesystem as unknown as IFS);
+
+    return source;
+  }
+}

package/src/Source.ts

@@ -0,0 +1,178 @@
+import EventEmitter from 'events';
+import { Volume } from 'memfs';
+import util from 'util';
+import md5 from 'md5';
+import path from 'path';
+
+import type PluginModuleDefinition from '@jpmorganchase/mosaic-types/dist/PluginModuleDefinition';
+import type SerialiserModuleDefinition from '@jpmorganchase/mosaic-types/dist/SerialiserModuleDefinition';
+import type { IUnionVolume, IVolumeImmutable } from '@jpmorganchase/mosaic-types/dist/Volume';
+import type Serialiser from '@jpmorganchase/mosaic-types/dist/Serialiser';
+import type MutableData from '@jpmorganchase/mosaic-types/dist/MutableData';
+import type Plugin from '@jpmorganchase/mosaic-types/dist/Plugin';
+import type SourceModuleDefinition from '@jpmorganchase/mosaic-types/dist/SourceModuleDefinition';
+
+import { bindSerialiser, bindPluginMethods } from './plugin';
+import WorkerSubscription from './WorkerSubscription';
+import { EVENT } from './WorkerSubscription';
+import createConfig from './helpers/createConfig';
+import MutableVolume from './filesystems/MutableVolume';
+import FileAccess from './filesystems/FileAccess';
+
+export default class Source {
+  #emitter: EventEmitter = new EventEmitter();
+  #modulePath: string;
+  #plugins: PluginModuleDefinition[] = [];
+  #serialisers: SerialiserModuleDefinition[] = [];
+  #worker: WorkerSubscription;
+  #globalFilesystem: IUnionVolume;
+  #pluginApi: Plugin;
+  #mergedOptions: Record<string, unknown>;
+  #pageExtensions: string[];
+  #ignorePages: string[];
+
+  config: MutableData<{}>;
+  serialiser: Serialiser;
+  namespace: string;
+  id: Symbol;
+  filesystem: MutableVolume;
+
+  constructor(
+    { modulePath, namespace }: SourceModuleDefinition,
+    mergedOptions: Record<string, unknown>,
+    pageExtensions: string[],
+    ignorePages: string[],
+    globalFilesystem: IUnionVolume
+  ) {
+    this.#modulePath = modulePath;
+    this.#mergedOptions = mergedOptions;
+    this.#globalFilesystem = globalFilesystem;
+    this.#ignorePages = ignorePages;
+    this.namespace = namespace;
+    this.id = Symbol(
+      `${path.basename(path.dirname(path.resolve(modulePath, '../')))}#${md5(
+        util.inspect(this.#mergedOptions, { sorted: true })
+      ).substring(0, 8)}`
+    );
+    this.filesystem = new MutableVolume(new FileAccess(new Volume()), this.namespace);
+    this.#pageExtensions = pageExtensions;
+  }
+
+  onUpdate(callback) {
+    this.#emitter.on(EVENT.UPDATE, callback);
+
+    return () => this.#emitter.off(EVENT.UPDATE, callback);
+  }
+
+  onError(callback) {
+    this.#emitter.once(EVENT.ERROR, callback);
+
+    return () => this.#emitter.off(EVENT.ERROR, callback);
+  }
+
+  onStart(callback) {
+    this.#emitter.once(EVENT.START, callback);
+
+    return () => this.#emitter.off(EVENT.START, callback);
+  }
+
+  onExit(callback) {
+    this.#emitter.once(EVENT.EXIT, callback);
+
+    return () => this.#emitter.off(EVENT.EXIT, callback);
+  }
+
+  stop() {
+    if (this.#worker && this.#worker.closed) {
+      throw new Error('Cannot stop source that has not started');
+    }
+    if (this.#worker) {
+      this.#worker.stop();
+    }
+  }
+
+  /**
+   * Called when another source (not this one) has changed.
+   * This source can then ask its plugins if they also want to clear their cache in response to the other source's change.
+   */
+  async requestCacheClear(updatedSourceFilesystem: IVolumeImmutable) {
+    const initTime = new Date().getTime();
+    const shouldInvokeAfterUpdate = await this.#pluginApi.shouldClearCache(
+      updatedSourceFilesystem,
+      {
+        globalFilesystem: this.#globalFilesystem,
+        pageExtensions: this.#pageExtensions,
+        ignorePages: this.#ignorePages,
+        serialiser: this.serialiser,
+        config: this.config.asReadOnly()
+      }
+    );
+    const timeTaken = new Date().getTime() - initTime;
+    if (timeTaken > 400) {
+      console.warn(
+        `Lifecycle phase 'shouldClearCache' for source '${this.id.description}' took ${timeTaken}ms to complete. The method is async, so this may not be an accurate measurement of execution time, but consider optimising this method if it is performing intensive operations.`
+      );
+    }
+    if (shouldInvokeAfterUpdate === true) {
+      this.filesystem.clearCache();
+    }
+  }
+
+  async use(plugins: PluginModuleDefinition[] = [], serialisers: SerialiserModuleDefinition[] = []) {
+    this.#plugins.push(...plugins);
+    this.#serialisers.push(...serialisers);
+  }
+
+  async invokeAfterUpdate(sharedFilesystem, globalConfig) {
+    const initTime = new Date().getTime();
+    await this.#pluginApi.afterUpdate(this.filesystem.asRestricted(), {
+      globalFilesystem: this.#globalFilesystem,
+      sharedFilesystem,
+      globalConfig,
+      pageExtensions: this.#pageExtensions,
+      ignorePages: this.#ignorePages,
+      serialiser: this.serialiser,
+      config: this.config.asReadOnly()
+    });
+    const timeTaken = new Date().getTime() - initTime;
+    if (timeTaken > 800) {
+      console.warn(
+        `Lifecycle phase 'afterUpdate' for source '${this.id.description}' took ${
+          timeTaken / 1000
+        }s to complete. The method is async, so this may not be an accurate measurement of execution time, but consider optimising this method if it is performing intensive operations.`
+      );
+    }
+  }
+
+  #createWorker() {
+    const worker = new WorkerSubscription({
+      modulePath: this.#modulePath,
+      name: this.id.description,
+      options: this.#mergedOptions,
+      namespace: this.namespace,
+      pageExtensions: this.#pageExtensions,
+      ignorePages: this.#ignorePages,
+      plugins: this.#plugins,
+      serialisers: this.#serialisers
+    });
+    worker.once(EVENT.ERROR, error => this.#emitter.emit(EVENT.ERROR, error));
+    worker.once(EVENT.EXIT, () => {
+      this.#emitter.emit(EVENT.EXIT);
+      this.#emitter.removeAllListeners();
+      //this.filesystem.reset();
+      this.filesystem = null;
+    });
+    worker.once(EVENT.START, () => this.#emitter.emit(EVENT.START));
+    return worker;
+  }
+
+  async start() {
+    this.serialiser = await bindSerialiser(this.#serialisers);
+    this.#pluginApi = await bindPluginMethods(this.#plugins);
+    this.#worker = this.#createWorker();
+    this.#worker.on(EVENT.UPDATE, async ({ data: { pages, symlinks, data } }) => {
+      this.config = createConfig(data);
+      this.#emitter.emit(EVENT.UPDATE, { pages, symlinks, data });
+    });
+  }
+}

package/src/SourceManager.ts

@@ -0,0 +1,196 @@
+import type SourceModuleDefinition from '@jpmorganchase/mosaic-types/dist/SourceModuleDefinition';
+import type SerialiserModuleDefinition from '@jpmorganchase/mosaic-types/dist/SerialiserModuleDefinition';
+import type PluginModuleDefinition from '@jpmorganchase/mosaic-types/dist/PluginModuleDefinition';
+import type {
+  IUnionVolume,
+  IVolumeImmutable,
+  IVolumeMutable
+} from '@jpmorganchase/mosaic-types/dist/Volume';
+
+import Source from './Source';
+import createConfig from './helpers/createConfig';
+import { merge } from 'lodash';
+
+export default class SourceManager {
+  #sources: Map<Symbol, Source> = new Map();
+  #plugins: PluginModuleDefinition[];
+  #serialisers: SerialiserModuleDefinition[];
+  #handlers: Set<(filesystem: IVolumeImmutable, source: Source) => {}> = new Set();
+  #globalFilesystem: IUnionVolume;
+  #sharedFilesystem: IVolumeMutable;
+  #pageExtensions: string[];
+  #ignorePages: string[];
+  #globalConfig = createConfig();
+
+  constructor(
+    plugins = [],
+    serialisers = [],
+    pageExtensions,
+    ignorePages,
+    globalFilesystem,
+    sharedFilesystem
+  ) {
+    this.#plugins = plugins;
+    this.#pageExtensions = pageExtensions;
+    this.#ignorePages = ignorePages;
+    this.#serialisers = serialisers;
+    this.#globalFilesystem = globalFilesystem;
+    this.#sharedFilesystem = sharedFilesystem;
+  }
+
+  onSourceUpdate(callback) {
+    const handler = (filesystem: IVolumeImmutable, source: Source) => callback(filesystem, source);
+
+    this.#handlers.add(handler);
+
+    return () => this.#handlers.delete(handler);
+  }
+
+  getSource(id: Symbol) {
+    return this.#sources.get(id);
+  }
+
+  destroyAll() {
+    this.#sources.forEach(source => source.stop());
+  }
+
+  addSource(
+    sourceDefinition: SourceModuleDefinition,
+    options: Record<string, unknown>
+  ): Promise<Source> {
+    return new Promise(async (resolve, reject) => {
+      let sourceActive = false;
+
+      const source = new Source(
+        sourceDefinition,
+        {
+          ...sourceDefinition.options,
+          ...options
+        },
+        this.#pageExtensions,
+        this.#ignorePages,
+        this.#globalFilesystem
+      );
+      const immutableSourceFilesystem = source.filesystem.asReadOnly();
+
+      let initOrStartTime = new Date().getTime();
+
+      this.#sources.set(source.id, source);
+
+      source.use(this.#plugins, this.#serialisers);
+
+      await source.start();
+
+      source.onUpdate(async ({ pages, symlinks, data }) => {
+        if (!sourceActive) {
+          reject(
+            new Error(
+              `Source '${source.id.description}' received a message before it was initialised.`
+            )
+          );
+        } else {
+          logUpdateStatus(source.id, initOrStartTime);
+          initOrStartTime = null;
+
+          //
+          try {
+            this.#globalConfig.setData(
+              Array.from(this.#sources.values()).reduce(
+                (mergedConfig, { config }) => merge(mergedConfig, config?.data || {}),
+                {}
+              ),
+              true
+            );
+            source.filesystem.reset();
+            source.filesystem.fromJSON(pages);
+            // We need to re-apply symlinks in the main thread
+            await source.filesystem.symlinksFromJSON(symlinks);
+
+            // After each async operation, we should check if anything has caused the Source to close
+            if (!sourceActive) {
+              return;
+            }
+
+            await source.invokeAfterUpdate(this.#sharedFilesystem, this.#globalConfig);
+
+            // After each async operation, we should check if anything has caused the Source to close
+            if (!sourceActive) {
+              return;
+            }
+
+            source.filesystem.freeze();
+            source.filesystem.clearCache();
+
+            await this.#updateSources(immutableSourceFilesystem, source);
+            this.#invokeUpdateCallbacks(immutableSourceFilesystem, source);
+          } catch (e) {
+            console.warn(
+              `[PullDocs] Exceptions during source update are currently set to terminate the parent source. Terminating '${String(
+                source.id.description
+              )}'. See error:`
+            );
+            console.error(e);
+            source.stop();
+          }
+          //
+        }
+      });
+      source.onError(error => {
+        console.error(error);
+        if (!sourceActive) {
+          reject(error);
+        }
+      });
+      source.onExit(() => {
+        if (!sourceActive) {
+          reject(
+            new Error(`Source '${source.id.description}' silently exited before initialising.`)
+          );
+        }
+        console.debug(`[PullDocs] Source '${source.id.description}' closed`);
+
+        this.#sources.delete(source.id);
+        sourceActive = false;
+      });
+      source.onStart(() => {
+        sourceActive = true;
+        console.debug(
+          `[PullDocs] Source '${source.id.description}' started in ${
+            new Date().getTime() - initOrStartTime
+          }ms - awaiting first docs snapshot`
+        );
+        initOrStartTime = new Date().getTime();
+        resolve(source);
+      });
+    });
+  }
+
+  #invokeUpdateCallbacks(filesystem: IVolumeImmutable, source: Source) {
+    this.#handlers.forEach(callback => callback(filesystem, source));
+  }
+
+  #updateSources(immutableSourceFilesystem, source) {
+    // Notify other frozen sources that something has changed. If a source's filesystem hasn't been frozen yet - there's no point
+    // in notifying it of another source changing, as it hasn't initialised or called `afterUpdate` for the first time yet anyway.
+    // No need to do them sequentially - we can fire them all off at once and wait for them all to finish in their own time
+    return Promise.all(
+      Array.from(this.#sources.values()).map(existingSource => {
+        if (existingSource !== source && existingSource.filesystem.frozen) {
+          return existingSource.requestCacheClear(immutableSourceFilesystem);
+        }
+      })
+    );
+  }
+}
+
+function logUpdateStatus(sourceId, initOrStartTime) {
+  if (initOrStartTime) {
+    console.debug(
+      `[PullDocs] Source '${sourceId.description}' received first docs snapshot ${
+        (new Date().getTime() - initOrStartTime) / 1000
+      }s after starting.`
+    );
+  } else {
+    console.debug(`[PullDocs] Source '${sourceId.description}' received updated docs`);
+  }
+}

package/src/WorkerSubscription.ts

@@ -0,0 +1,80 @@
+import { EventEmitter } from 'stream';
+import type { Subscription } from 'rxjs';
+
+import * as ObservableWorker from './operators/ObservableWorker';
+
+export enum EVENT {
+  ERROR = 'ERROR',
+  EXIT = 'EXIT',
+  START = 'START',
+  UPDATE = 'UPDATE'
+}
+
+const textDecoder = new TextDecoder('utf8');
+
+export default class WorkerSubscription {
+  #worker$: Subscription;
+  #emitter = new EventEmitter();
+
+  constructor(workerData) {
+    this.#worker$ = ObservableWorker.from<{ type: 'message' | 'init'; data: Uint8Array }>(
+      workerData
+    ).subscribe({ next: this.#onNext, error: this.#onError, complete: this.#onComplete });
+  }
+
+  get closed() {
+    return this.#worker$?.closed;
+  }
+
+  stop() {
+    if (this.closed) {
+      throw new Error('Cannot stop source - subscription is already closed');
+    }
+    this.#worker$.unsubscribe();
+    this.#onComplete();
+  }
+
+  once(type: EVENT, handler) {
+    const autoUnsubscribeHandler = (...args) => {
+      this.#emitter.off(type, autoUnsubscribeHandler);
+      handler(...args);
+    };
+    this.on(type, autoUnsubscribeHandler);
+
+    return () => this.#emitter.off(type, autoUnsubscribeHandler);
+  }
+
+  on(type: EVENT, handler) {
+    this.#emitter.on(type, handler);
+
+    return () => this.#emitter.off(type, handler);
+  }
+
+  #onNext = ({ type, data }: { data: Uint8Array; type: 'init' | 'message' }) => {
+    if (type === 'message') {
+      this.#emitter.emit(EVENT.UPDATE, { data: JSON.parse(textDecoder.decode(data)) });
+    } else if (type === 'init') {
+      this.#emitter.emit(EVENT.START);
+      if (data) {
+        // We receive a file buffer for 'init', not an object
+        this.#emitter.emit(EVENT.UPDATE, { data: JSON.parse(textDecoder.decode(data)) });
+      }
+    } else {
+      this.#onError(
+        new Error(`Unsupported type '${type}' with value of '${data}' received from source worker.`)
+      );
+      this.#worker$.unsubscribe();
+      this.#worker$ = null;
+    }
+  };
+
+  #onError = e => {
+    this.#emitter.emit(EVENT.ERROR, e);
+    this.#onComplete();
+  };
+
+  #onComplete = () => {
+    this.#emitter.emit(EVENT.EXIT);
+    this.#emitter.removeAllListeners();
+  };
+}

package/src/__mocks__/Source.ts

@@ -0,0 +1,29 @@
+const constructorSpy = jest.fn();
+
+class Source {
+  constructor(...args) {
+    constructorSpy(...args);
+    this.filesystem = {
+      asReadOnly: jest.fn(),
+      clearCache: jest.fn(),
+      freeze: jest.fn(),
+      fromJSON: jest.fn(),
+      reset: jest.fn(),
+      symlinksFromJSON: () => new Promise(resolve => setTimeout(resolve))
+    };
+    this.id = Symbol(args[0].name || 'some description');
+  }
+}
+
+Source.prototype.onError = jest.fn();
+Source.prototype.onExit = jest.fn();
+Source.prototype.onStart = jest.fn();
+Source.prototype.onUpdate = jest.fn();
+Source.prototype.invokeAfterUpdate = () => new Promise(resolve => setTimeout(resolve));
+Source.prototype.requestCacheClear = jest.fn();
+Source.prototype.start = jest.fn();
+Source.prototype.stop = jest.fn();
+Source.prototype.use = jest.fn();
+Source.prototype.constructorSpy = constructorSpy;
+
+export default Source;