feat(xo-server-test/backupNg.spec.js): test on 'backupNg.importVmBackup'

See #4307

.eslintrc.js

@@ -1,7 +1,13 @@
-'use strict'
-
 module.exports = {
-  extends: ['plugin:eslint-comments/recommended', 'plugin:n/recommended', 'standard', 'standard-jsx', 'prettier'],
+  extends: [
+    'plugin:eslint-comments/recommended',
+
+    'standard',
+    'standard-jsx',
+    'prettier',
+    'prettier/standard',
+    'prettier/react',
+  ],
   globals: {
     __DEV__: true,
     $Dict: true,
@@ -15,57 +21,27 @@ module.exports = {
 
   overrides: [
     {
-      files: ['cli.{,c,m}js', '*-cli.{,c,m}js', '**/*cli*/**/*.{,c,m}js'],
+      files: ['cli.js', '*-cli.js', 'packages/*cli*/**/*.js'],
       rules: {
-        'n/no-process-exit': 'off',
         'no-console': 'off',
       },
     },
-    {
-      files: ['*.mjs'],
-      parserOptions: {
-        sourceType: 'module',
-      },
-    },
-    {
-      files: ['*.spec.{,c,m}js'],
-      rules: {
-        'n/no-unsupported-features/node-builtins': [
-          'error',
-          {
-            version: '>=16',
-          },
-        ],
-        'n/no-unsupported-features/es-syntax': [
-          'error',
-          {
-            version: '>=16',
-          },
-        ],
-      },
-    },
   ],
 
+  parser: 'babel-eslint',
   parserOptions: {
-    ecmaVersion: 13,
-    sourceType: 'script',
+    ecmaFeatures: {
+      legacyDecorators: true,
+    },
   },
-
   rules: {
     // disabled because XAPI objects are using camel case
     camelcase: ['off'],
 
-    'react/jsx-handler-names': 'off',
-
-    // disabled because not always relevant, we might reconsider in the future
-    //
-    // enabled by https://github.com/standard/eslint-config-standard/commit/319b177750899d4525eb1210686f6aca96190b2f
-    //
-    // example: https://github.com/vatesfr/xen-orchestra/blob/31ed3767c67044ca445658eb6b560718972402f2/packages/xen-api/src/index.js#L156-L157
-    'lines-between-class-members': 'off',
-
     'no-console': ['error', { allow: ['warn', 'error'] }],
-
-    strict: 'error',
+    'no-var': 'error',
+    'node/no-extraneous-import': 'error',
+    'node/no-extraneous-require': 'error',
+    'prefer-const': 'error',
   },
 }

.flowconfig

@@ -0,0 +1,16 @@
+[ignore]
+<PROJECT_ROOT>/node_modules/.*
+
+[include]
+
+[libs]
+
+[lints]
+
+[options]
+esproposal.decorators=ignore
+esproposal.optional_chaining=enable
+include_warnings=true
+module.use_strict=true
+
+[strict]

.github/ISSUE_TEMPLATE/bug_report.md

@@ -1,46 +0,0 @@
----
-name: Bug report
-about: Create a report to help us improve
-title: ''
-labels: 'status: triaging :triangular_flag_on_post:, type: bug :bug:'
-assignees: ''
----
-
-**XOA or XO from the sources?**
-
-If XOA:
-
-- which release channel? (`stable` vs `latest`)
-- please consider creating a support ticket in [your dedicated support area](https://xen-orchestra.com/#!/member/support)
-
-If XO from the sources:
-
-- Don't forget to [read this first](https://xen-orchestra.com/docs/community.html)
-- As well as follow [this guide](https://xen-orchestra.com/docs/community.html#report-a-bug)
-
-**Describe the bug**
-A clear and concise description of what the bug is.
-
-**To Reproduce**
-Steps to reproduce the behavior:
-
-1. Go to '...'
-2. Click on '....'
-3. Scroll down to '....'
-4. See error
-
-**Expected behavior**
-A clear and concise description of what you expected to happen.
-
-**Screenshots**
-If applicable, add screenshots to help explain your problem.
-
-**Environment (please provide the following information):**
-
-- Node: [e.g. 16.12.1]
-- xo-server: [e.g. 5.82.3]
-- xo-web: [e.g. 5.87.0]
-- hypervisor: [e.g. XCP-ng 8.2.0]
-
-**Additional context**
-Add any other context about the problem here.

.github/ISSUE_TEMPLATE/feature_request.md

@@ -1,19 +0,0 @@
----
-name: Feature request
-about: Suggest an idea for this project
-title: ''
-labels: ''
-assignees: ''
----
-
-**Is your feature request related to a problem? Please describe.**
-A clear and concise description of what the problem is. Ex. I'm always frustrated when [...]
-
-**Describe the solution you'd like**
-A clear and concise description of what you want to happen.
-
-**Describe alternatives you've considered**
-A clear and concise description of any alternative solutions or features you've considered.
-
-**Additional context**
-Add any other context or screenshots about the feature request here.

.github/workflows/push.yml

@@ -1,13 +0,0 @@
-name: CI
-on: [push]
-jobs:
-  build:
-    name: Test
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v3
-      - uses: satackey/action-docker-layer-caching@v0.0.11
-      # Ignore the failure of a step and avoid terminating the job.
-        continue-on-error: true
-      - run: docker-compose  -f docker/docker-compose.dev.yml build
-      - run: docker-compose  -f docker/docker-compose.dev.yml up

.gitignore

@@ -1,22 +1,23 @@
 /_book/
+/coverage/
 /node_modules/
 /lerna-debug.log
 /lerna-debug.log.*
 
-/@vates/*/dist/
-/@vates/*/node_modules/
 /@xen-orchestra/*/dist/
 /@xen-orchestra/*/node_modules/
 /packages/*/dist/
 /packages/*/node_modules/
 
+/packages/vhd-cli/src/commands/index.js
+
 /packages/xen-api/examples/node_modules/
 /packages/xen-api/plot.dat
 
 /packages/xo-server/.xo-server.*
-/packages/xo-server/src/api/index.mjs
-/packages/xo-server/src/xapi/mixins/index.mjs
-/packages/xo-server/src/xo-mixins/index.mjs
+/packages/xo-server/src/api/index.js
+/packages/xo-server/src/xapi/mixins/index.js
+/packages/xo-server/src/xo-mixins/index.js
 
 /packages/xo-server-auth-ldap/ldap.cache.conf
 
@@ -30,7 +31,3 @@ pnpm-debug.log.*
 yarn-error.log
 yarn-error.log.*
 .env
-
-# code coverage
-.nyc_output/
-coverage/

.prettierrc.js

@@ -1,11 +1,6 @@
 module.exports = {
-  arrowParens: 'avoid',
   jsxSingleQuote: true,
   semi: false,
   singleQuote: true,
-
-  // 2020-11-24: Requested by nraynaud and approved by the rest of the team
-  //
-  // https://team.vates.fr/vates/pl/a1i8af1b9id7pgzm3jcg4toacy
-  printWidth: 120,
+  trailingComma: 'es5',
 }

.travis.yml

@@ -0,0 +1,24 @@
+language: node_js
+node_js:
+  #- stable # disable for now due to an issue of indirect dep upath with Node 9
+  - 8
+
+# Use containers.
+# http://docs.travis-ci.com/user/workers/container-based-infrastructure/
+sudo: false
+addons:
+  apt:
+    packages:
+      - qemu-utils
+      - blktap-utils
+      - vmdk-stream-converter
+
+before_install:
+  - curl -o- -L https://yarnpkg.com/install.sh | bash
+  - export PATH="$HOME/.yarn/bin:$PATH"
+
+cache:
+  yarn: true
+
+script:
+  - yarn run travis-tests

@vates/async-each/.USAGE.md

@@ -1,35 +0,0 @@
-### `asyncEach(iterable, iteratee, [opts])`
-
-Executes `iteratee` in order for each value yielded by `iterable`.
-
-Returns a promise wich rejects as soon as a call to `iteratee` throws or a promise returned by it rejects, and which resolves when all promises returned by `iteratee` have resolved.
-
-`iterable` must be an iterable or async iterable.
-
-`iteratee` is called with the same `this` value as `asyncEach`, and with the following arguments:
-
-- `value`: the value yielded by `iterable`
-- `index`: the 0-based index for this value
-- `iterable`: the iterable itself
-
-`opts` is an object that can contains the following options:
-
-- `concurrency`: a number which indicates the maximum number of parallel call to `iteratee`, defaults to `10`. The value `0` means no concurrency limit.
-- `signal`: an abort signal to stop the iteration
-- `stopOnError`: wether to stop iteration of first error, or wait for all calls to finish and throw an `AggregateError`, defaults to `true`
-
-```js
-import { asyncEach } from '@vates/async-each'
-
-const contents = []
-await asyncEach(
-  ['foo.txt', 'bar.txt', 'baz.txt'],
-  async function (filename, i) {
-    contents[i] = await readFile(filename)
-  },
-  {
-    // reads two files at a time
-    concurrency: 2,
-  }
-)
-```

@vates/async-each/.npmignore

@@ -1 +0,0 @@
-../../scripts/npmignore

@vates/async-each/README.md

@@ -1,68 +0,0 @@
-<!-- DO NOT EDIT MANUALLY, THIS FILE HAS BEEN GENERATED -->
-
-# @vates/async-each
-
-[![Package Version](https://badgen.net/npm/v/@vates/async-each)](https://npmjs.org/package/@vates/async-each) ![License](https://badgen.net/npm/license/@vates/async-each) [![PackagePhobia](https://badgen.net/bundlephobia/minzip/@vates/async-each)](https://bundlephobia.com/result?p=@vates/async-each) [![Node compatibility](https://badgen.net/npm/node/@vates/async-each)](https://npmjs.org/package/@vates/async-each)
-
-> Run async fn for each item in (async) iterable
-
-## Install
-
-Installation of the [npm package](https://npmjs.org/package/@vates/async-each):
-
-```
-> npm install --save @vates/async-each
-```
-
-## Usage
-
-### `asyncEach(iterable, iteratee, [opts])`
-
-Executes `iteratee` in order for each value yielded by `iterable`.
-
-Returns a promise wich rejects as soon as a call to `iteratee` throws or a promise returned by it rejects, and which resolves when all promises returned by `iteratee` have resolved.
-
-`iterable` must be an iterable or async iterable.
-
-`iteratee` is called with the same `this` value as `asyncEach`, and with the following arguments:
-
-- `value`: the value yielded by `iterable`
-- `index`: the 0-based index for this value
-- `iterable`: the iterable itself
-
-`opts` is an object that can contains the following options:
-
-- `concurrency`: a number which indicates the maximum number of parallel call to `iteratee`, defaults to `10`. The value `0` means no concurrency limit.
-- `signal`: an abort signal to stop the iteration
-- `stopOnError`: wether to stop iteration of first error, or wait for all calls to finish and throw an `AggregateError`, defaults to `true`
-
-```js
-import { asyncEach } from '@vates/async-each'
-
-const contents = []
-await asyncEach(
-  ['foo.txt', 'bar.txt', 'baz.txt'],
-  async function (filename, i) {
-    contents[i] = await readFile(filename)
-  },
-  {
-    // reads two files at a time
-    concurrency: 2,
-  }
-)
-```
-
-## Contributions
-
-Contributions are _very_ welcomed, either on the documentation or on
-the code.
-
-You may:
-
-- report any [issue](https://github.com/vatesfr/xen-orchestra/issues)
-  you've encountered;
-- fork and create a pull request.
-
-## License
-
-[ISC](https://spdx.org/licenses/ISC) © [Vates SAS](https://vates.fr)

@vates/async-each/index.js

@@ -1,108 +0,0 @@
-'use strict'
-
-const noop = Function.prototype
-
-class AggregateError extends Error {
-  constructor(errors, message) {
-    super(message)
-    this.errors = errors
-  }
-}
-
-/**
- * @template Item
- * @param {Iterable<Item>} iterable
- * @param {(item: Item, index: number, iterable: Iterable<Item>) => Promise<void>} iteratee
- * @returns {Promise<void>}
- */
-exports.asyncEach = function asyncEach(iterable, iteratee, { concurrency = 10, signal, stopOnError = true } = {}) {
-  if (concurrency === 0) {
-    concurrency = Infinity
-  }
-  return new Promise((resolve, reject) => {
-    const it = (iterable[Symbol.iterator] || iterable[Symbol.asyncIterator]).call(iterable)
-    const errors = []
-    let running = 0
-    let index = 0
-
-    let onAbort
-    if (signal !== undefined) {
-      onAbort = () => {
-        onRejectedWrapper(new Error('asyncEach aborted'))
-      }
-      signal.addEventListener('abort', onAbort)
-    }
-
-    const clean = () => {
-      onFulfilled = onRejected = noop
-      if (onAbort !== undefined) {
-        signal.removeEventListener('abort', onAbort)
-      }
-    }
-
-    resolve = (resolve =>
-      function resolveAndClean(value) {
-        resolve(value)
-        clean()
-      })(resolve)
-    reject = (reject =>
-      function rejectAndClean(reason) {
-        reject(reason)
-        clean()
-      })(reject)
-
-    let onFulfilled = value => {
-      --running
-      next()
-    }
-    const onFulfilledWrapper = value => onFulfilled(value)
-
-    let onRejected = stopOnError
-      ? reject
-      : error => {
-          --running
-          errors.push(error)
-          next()
-        }
-    const onRejectedWrapper = reason => onRejected(reason)
-
-    let nextIsRunning = false
-    let next = async () => {
-      if (nextIsRunning) {
-        return
-      }
-      nextIsRunning = true
-      if (running < concurrency) {
-        const cursor = await it.next()
-        if (cursor.done) {
-          next = () => {
-            if (running === 0) {
-              if (errors.length === 0) {
-                resolve()
-              } else {
-                reject(new AggregateError(errors))
-              }
-            }
-          }
-        } else {
-          ++running
-          try {
-            const result = iteratee.call(this, cursor.value, index++, iterable)
-            let then
-            if (result != null && typeof result === 'object' && typeof (then = result.then) === 'function') {
-              then.call(result, onFulfilledWrapper, onRejectedWrapper)
-            } else {
-              onFulfilled(result)
-            }
-          } catch (error) {
-            onRejected(error)
-          }
-        }
-        nextIsRunning = false
-        return next()
-      }
-      nextIsRunning = false
-    }
-    next()
-  })
-}

@vates/async-each/index.spec.js

@@ -1,101 +0,0 @@
-'use strict'
-
-/* eslint-env jest */
-
-const { asyncEach } = require('./')
-
-const randomDelay = (max = 10) =>
-  new Promise(resolve => {
-    setTimeout(resolve, Math.floor(Math.random() * max + 1))
-  })
-
-const rejectionOf = p =>
-  new Promise((resolve, reject) => {
-    p.then(reject, resolve)
-  })
-
-describe('asyncEach', () => {
-  const thisArg = 'qux'
-  const values = ['foo', 'bar', 'baz']
-
-  Object.entries({
-    'sync iterable': () => values,
-    'async iterable': async function* () {
-      for (const value of values) {
-        await randomDelay()
-        yield value
-      }
-    },
-  }).forEach(([what, getIterable]) =>
-    describe('with ' + what, () => {
-      let iterable
-      beforeEach(() => {
-        iterable = getIterable()
-      })
-
-      it('works', async () => {
-        const iteratee = jest.fn(async () => {})
-
-        await asyncEach.call(thisArg, iterable, iteratee, { concurrency: 1 })
-
-        expect(iteratee.mock.instances).toEqual(Array.from(values, () => thisArg))
-        expect(iteratee.mock.calls).toEqual(Array.from(values, (value, index) => [value, index, iterable]))
-      })
-      ;[1, 2, 4].forEach(concurrency => {
-        it('respects a concurrency of ' + concurrency, async () => {
-          let running = 0
-
-          await asyncEach(
-            values,
-            async () => {
-              ++running
-              expect(running).toBeLessThanOrEqual(concurrency)
-              await randomDelay()
-              --running
-            },
-            { concurrency }
-          )
-        })
-      })
-
-      it('stops on first error when stopOnError is true', async () => {
-        const error = new Error()
-        const iteratee = jest.fn((_, i) => {
-          if (i === 1) {
-            throw error
-          }
-        })
-
-        expect(await rejectionOf(asyncEach(iterable, iteratee, { concurrency: 1, stopOnError: true }))).toBe(error)
-        expect(iteratee).toHaveBeenCalledTimes(2)
-      })
-
-      it('rejects AggregateError when stopOnError is false', async () => {
-        const errors = []
-        const iteratee = jest.fn(() => {
-          const error = new Error()
-          errors.push(error)
-          throw error
-        })
-
-        const error = await rejectionOf(asyncEach(iterable, iteratee, { stopOnError: false }))
-        expect(error.errors).toEqual(errors)
-        expect(iteratee.mock.calls).toEqual(Array.from(values, (value, index) => [value, index, iterable]))
-      })
-
-      it('can be interrupted with an AbortSignal', async () => {
-        const ac = new AbortController()
-        const iteratee = jest.fn((_, i) => {
-          if (i === 1) {
-            ac.abort()
-          }
-        })
-
-        await expect(asyncEach(iterable, iteratee, { concurrency: 1, signal: ac.signal })).rejects.toThrow(
-          'asyncEach aborted'
-        )
-        expect(iteratee).toHaveBeenCalledTimes(2)
-      })
-    })
-  )
-})

@vates/async-each/package.json

@@ -1,34 +0,0 @@
-{
-  "private": false,
-  "name": "@vates/async-each",
-  "homepage": "https://github.com/vatesfr/xen-orchestra/tree/master/@vates/async-each",
-  "description": "Run async fn for each item in (async) iterable",
-  "keywords": [
-    "array",
-    "async",
-    "collection",
-    "each",
-    "for",
-    "foreach",
-    "iterable",
-    "iterator"
-  ],
-  "bugs": "https://github.com/vatesfr/xen-orchestra/issues",
-  "repository": {
-    "directory": "@vates/async-each",
-    "type": "git",
-    "url": "https://github.com/vatesfr/xen-orchestra.git"
-  },
-  "author": {
-    "name": "Vates SAS",
-    "url": "https://vates.fr"
-  },
-  "license": "ISC",
-  "version": "1.0.0",
-  "engines": {
-    "node": ">=8.10"
-  },
-  "scripts": {
-    "postversion": "npm publish --access public"
-  }
-}

@vates/cached-dns.lookup/.USAGE.md

@@ -1,30 +0,0 @@
-Node does not cache queries to `dns.lookup`, which can lead application doing a lot of connections to have perf issues and to saturate Node threads pool.
-
-This library attempts to mitigate these problems by providing a version of this function with a version short cache, applied on both errors and results.
-
-> Limitation: `verbatim: false` option is not supported.
-
-It has exactly the same API as the native method and can be used directly:
-
-```js
-import { createCachedLookup } from '@vates/cached-dns.lookup'
-
-const lookup = createCachedLookup()
-
-lookup('example.net', { all: true, family: 0 }, (error, result) => {
-  if (error != null) {
-    return console.warn(error)
-  }
-  console.log(result)
-})
-```
-
-Or it can be used to replace the native implementation and speed up the whole app:
-
-```js
-// assign our cached implementation to dns.lookup
-const restore = createCachedLookup().patchGlobal()
-
-// to restore the previous implementation
-restore()
-```

@vates/cached-dns.lookup/.npmignore

@@ -1 +0,0 @@
-../../scripts/npmignore

@vates/cached-dns.lookup/README.md

@@ -1,63 +0,0 @@
-<!-- DO NOT EDIT MANUALLY, THIS FILE HAS BEEN GENERATED -->
-
-# @vates/cached-dns.lookup
-
-[![Package Version](https://badgen.net/npm/v/@vates/cached-dns.lookup)](https://npmjs.org/package/@vates/cached-dns.lookup) ![License](https://badgen.net/npm/license/@vates/cached-dns.lookup) [![PackagePhobia](https://badgen.net/bundlephobia/minzip/@vates/cached-dns.lookup)](https://bundlephobia.com/result?p=@vates/cached-dns.lookup) [![Node compatibility](https://badgen.net/npm/node/@vates/cached-dns.lookup)](https://npmjs.org/package/@vates/cached-dns.lookup)
-
-> Cached implementation of dns.lookup
-
-## Install
-
-Installation of the [npm package](https://npmjs.org/package/@vates/cached-dns.lookup):
-
-```
-> npm install --save @vates/cached-dns.lookup
-```
-
-## Usage
-
-Node does not cache queries to `dns.lookup`, which can lead application doing a lot of connections to have perf issues and to saturate Node threads pool.
-
-This library attempts to mitigate these problems by providing a version of this function with a version short cache, applied on both errors and results.
-
-> Limitation: `verbatim: false` option is not supported.
-
-It has exactly the same API as the native method and can be used directly:
-
-```js
-import { createCachedLookup } from '@vates/cached-dns.lookup'
-
-const lookup = createCachedLookup()
-
-lookup('example.net', { all: true, family: 0 }, (error, result) => {
-  if (error != null) {
-    return console.warn(error)
-  }
-  console.log(result)
-})
-```
-
-Or it can be used to replace the native implementation and speed up the whole app:
-
-```js
-// assign our cached implementation to dns.lookup
-const restore = createCachedLookup().patchGlobal()
-
-// to restore the previous implementation
-restore()
-```
-
-## Contributions
-
-Contributions are _very_ welcomed, either on the documentation or on
-the code.
-
-You may:
-
-- report any [issue](https://github.com/vatesfr/xen-orchestra/issues)
-  you've encountered;
-- fork and create a pull request.
-
-## License
-
-[ISC](https://spdx.org/licenses/ISC) © [Vates SAS](https://vates.fr)

@vates/cached-dns.lookup/index.js

@@ -1,72 +0,0 @@
-'use strict'
-
-const assert = require('assert')
-const dns = require('dns')
-const LRU = require('lru-cache')
-
-function reportResults(all, results, callback) {
-  if (all) {
-    callback(null, results)
-  } else {
-    const first = results[0]
-    callback(null, first.address, first.family)
-  }
-}
-
-exports.createCachedLookup = function createCachedLookup({ lookup = dns.lookup } = {}) {
-  const cache = new LRU({
-    max: 500,
-
-    // 1 minute: long enough to be effective, short enough so there is no need to bother with DNS TTLs
-    ttl: 60e3,
-  })
-
-  function cachedLookup(hostname, options, callback) {
-    let all = false
-    let family = 0
-    if (typeof options === 'function') {
-      callback = options
-    } else if (typeof options === 'number') {
-      family = options
-    } else if (options != null) {
-      assert.notStrictEqual(options.verbatim, false, 'not supported by this implementation')
-      ;({ all = all, family = family } = options)
-    }
-
-    // cache by family option because there will be an error if there is no
-    // entries for the requestion family so we cannot easily cache all families
-    // and filter on reporting back
-    const key = hostname + '/' + family
-
-    const result = cache.get(key)
-    if (result !== undefined) {
-      setImmediate(reportResults, all, result, callback)
-    } else {
-      lookup(hostname, { all: true, family, verbatim: true }, function onLookup(error, results) {
-        // errors are not cached because this will delay recovery after DNS/network issues
-        //
-        // there are no reliable way to detect if the error is real or simply
-        // that there are no results for the requested hostname
-        //
-        // there should be much fewer errors than success, therefore it should
-        // not be a big deal to not cache them
-        if (error != null) {
-          return callback(error)
-        }
-
-        cache.set(key, results)
-        reportResults(all, results, callback)
-      })
-    }
-  }
-  cachedLookup.patchGlobal = function patchGlobal() {
-    const previous = dns.lookup
-    dns.lookup = cachedLookup
-    return function restoreGlobal() {
-      assert.strictEqual(dns.lookup, cachedLookup)
-      dns.lookup = previous
-    }
-  }
-
-  return cachedLookup
-}

@vates/cached-dns.lookup/package.json

@@ -1,32 +0,0 @@
-{
-  "engines": {
-    "node": ">=8"
-  },
-  "dependencies": {
-    "lru-cache": "^7.0.4"
-  },
-  "private": false,
-  "name": "@vates/cached-dns.lookup",
-  "description": "Cached implementation of dns.lookup",
-  "keywords": [
-    "cache",
-    "dns",
-    "lookup"
-  ],
-  "homepage": "https://github.com/vatesfr/xen-orchestra/tree/master/@vates/cached-dns.lookup",
-  "bugs": "https://github.com/vatesfr/xen-orchestra/issues",
-  "repository": {
-    "directory": "@vates/cached-dns.lookup",
-    "type": "git",
-    "url": "https://github.com/vatesfr/xen-orchestra.git"
-  },
-  "author": {
-    "name": "Vates SAS",
-    "url": "https://vates.fr"
-  },
-  "license": "ISC",
-  "version": "1.0.0",
-  "scripts": {
-    "postversion": "npm publish --access public"
-  }
-}

@vates/coalesce-calls/.USAGE.md

@@ -1,13 +0,0 @@
-```js
-import { coalesceCalls } from '@vates/coalesce-calls'
-
-const connect = coalesceCalls(async function () {
-  // async operation
-})
-
-connect()
-
-// the previous promise result will be returned if the operation is not
-// complete yet
-connect()
-```

@vates/coalesce-calls/.npmignore

@@ -1 +0,0 @@
-../../scripts/npmignore

@vates/coalesce-calls/README.md

@@ -1,46 +0,0 @@
-<!-- DO NOT EDIT MANUALLY, THIS FILE HAS BEEN GENERATED -->
-
-# @vates/coalesce-calls
-
-[![Package Version](https://badgen.net/npm/v/@vates/coalesce-calls)](https://npmjs.org/package/@vates/coalesce-calls) ![License](https://badgen.net/npm/license/@vates/coalesce-calls) [![PackagePhobia](https://badgen.net/bundlephobia/minzip/@vates/coalesce-calls)](https://bundlephobia.com/result?p=@vates/coalesce-calls) [![Node compatibility](https://badgen.net/npm/node/@vates/coalesce-calls)](https://npmjs.org/package/@vates/coalesce-calls)
-
-> Wraps an async function so that concurrent calls will be coalesced
-
-## Install
-
-Installation of the [npm package](https://npmjs.org/package/@vates/coalesce-calls):
-
-```
-> npm install --save @vates/coalesce-calls
-```
-
-## Usage
-
-```js
-import { coalesceCalls } from '@vates/coalesce-calls'
-
-const connect = coalesceCalls(async function () {
-  // async operation
-})
-
-connect()
-
-// the previous promise result will be returned if the operation is not
-// complete yet
-connect()
-```
-
-## Contributions
-
-Contributions are _very_ welcomed, either on the documentation or on
-the code.
-
-You may:
-
-- report any [issue](https://github.com/vatesfr/xen-orchestra/issues)
-  you've encountered;
-- fork and create a pull request.
-
-## License
-
-[ISC](https://spdx.org/licenses/ISC) © [Vates SAS](https://vates.fr)

@vates/coalesce-calls/package.json

@@ -1,35 +0,0 @@
-{
-  "private": false,
-  "name": "@vates/coalesce-calls",
-  "description": "Wraps an async function so that concurrent calls will be coalesced",
-  "keywords": [
-    "async",
-    "calls",
-    "coalesce",
-    "decorate",
-    "decorator",
-    "merge",
-    "promise",
-    "wrap",
-    "wrapper"
-  ],
-  "homepage": "https://github.com/vatesfr/xen-orchestra/tree/master/@vates/coalesce-calls",
-  "bugs": "https://github.com/vatesfr/xen-orchestra/issues",
-  "repository": {
-    "directory": "@vates/coalesce-calls",
-    "type": "git",
-    "url": "https://github.com/vatesfr/xen-orchestra.git"
-  },
-  "author": {
-    "name": "Vates SAS",
-    "url": "https://vates.fr"
-  },
-  "license": "ISC",
-  "version": "0.1.0",
-  "engines": {
-    "node": ">=8.10"
-  },
-  "scripts": {
-    "postversion": "npm publish --access public"
-  }
-}

@vates/compose/.USAGE.md

@@ -1,65 +0,0 @@
-```js
-import { compose } from '@vates/compose'
-
-const add2 = x => x + 2
-const mul3 = x => x * 3
-
-// const f = x => mul3(add2(x))
-const f = compose(add2, mul3)
-
-console.log(f(5))
-// → 21
-```
-
-> The call context (`this`) of the composed function is forwarded to all functions.
-
-The first function is called with all arguments of the composed function:
-
-```js
-const add = (x, y) => x + y
-const mul3 = x => x * 3
-
-// const f = (x, y) => mul3(add(x, y))
-const f = compose(add, mul3)
-
-console.log(f(4, 5))
-// → 27
-```
-
-Functions may also be passed in an array:
-
-```js
-const f = compose([add2, mul3])
-```
-
-Options can be passed as first parameter:
-
-```js
-const f = compose(
-  {
-    // compose async functions
-    async: true,
-
-    // compose from right to left
-    right: true,
-  },
-  [add2, mul3]
-)
-```
-
-Functions can receive extra parameters:
-
-```js
-const isIn = (value, min, max) => min <= value && value <= max
-
-// Only compatible when `fns` is passed as an array!
-const f = compose([
-  [add, 2],
-  [isIn, 3, 10],
-])
-
-console.log(f(1))
-// → true
-```
-
-> Note: if the first function is defined with extra parameters, it will only receive the first value passed to the composed function, instead of all the parameters.

@vates/compose/.npmignore

@@ -1 +0,0 @@
-../../scripts/npmignore

@vates/compose/README.md

@@ -1,98 +0,0 @@
-<!-- DO NOT EDIT MANUALLY, THIS FILE HAS BEEN GENERATED -->
-
-# @vates/compose
-
-[![Package Version](https://badgen.net/npm/v/@vates/compose)](https://npmjs.org/package/@vates/compose) ![License](https://badgen.net/npm/license/@vates/compose) [![PackagePhobia](https://badgen.net/bundlephobia/minzip/@vates/compose)](https://bundlephobia.com/result?p=@vates/compose) [![Node compatibility](https://badgen.net/npm/node/@vates/compose)](https://npmjs.org/package/@vates/compose)
-
-> Compose functions from left to right
-
-## Install
-
-Installation of the [npm package](https://npmjs.org/package/@vates/compose):
-
-```
-> npm install --save @vates/compose
-```
-
-## Usage
-
-```js
-import { compose } from '@vates/compose'
-
-const add2 = x => x + 2
-const mul3 = x => x * 3
-
-// const f = x => mul3(add2(x))
-const f = compose(add2, mul3)
-
-console.log(f(5))
-// → 21
-```
-
-> The call context (`this`) of the composed function is forwarded to all functions.
-
-The first function is called with all arguments of the composed function:
-
-```js
-const add = (x, y) => x + y
-const mul3 = x => x * 3
-
-// const f = (x, y) => mul3(add(x, y))
-const f = compose(add, mul3)
-
-console.log(f(4, 5))
-// → 27
-```
-
-Functions may also be passed in an array:
-
-```js
-const f = compose([add2, mul3])
-```
-
-Options can be passed as first parameter:
-
-```js
-const f = compose(
-  {
-    // compose async functions
-    async: true,
-
-    // compose from right to left
-    right: true,
-  },
-  [add2, mul3]
-)
-```
-
-Functions can receive extra parameters:
-
-```js
-const isIn = (value, min, max) => min <= value && value <= max
-
-// Only compatible when `fns` is passed as an array!
-const f = compose([
-  [add, 2],
-  [isIn, 3, 10],
-])
-
-console.log(f(1))
-// → true
-```
-
-> Note: if the first function is defined with extra parameters, it will only receive the first value passed to the composed function, instead of all the parameters.
-
-## Contributions
-
-Contributions are _very_ welcomed, either on the documentation or on
-the code.
-
-You may:
-
-- report any [issue](https://github.com/vatesfr/xen-orchestra/issues)
-  you've encountered;
-- fork and create a pull request.
-
-## License
-
-[ISC](https://spdx.org/licenses/ISC) © [Vates SAS](https://vates.fr)

@vates/compose/index.js

@@ -1,66 +0,0 @@
-'use strict'
-
-const defaultOpts = { async: false, right: false }
-
-exports.compose = function compose(opts, fns) {
-  if (Array.isArray(opts)) {
-    fns = opts.slice() // don't mutate passed array
-    opts = defaultOpts
-  } else if (typeof opts === 'object') {
-    opts = Object.assign({}, defaultOpts, opts)
-    if (Array.isArray(fns)) {
-      fns = fns.slice() // don't mutate passed array
-    } else {
-      fns = Array.prototype.slice.call(arguments, 1)
-    }
-  } else {
-    fns = Array.from(arguments)
-    opts = defaultOpts
-  }
-
-  const n = fns.length
-  if (n === 0) {
-    throw new TypeError('at least one function must be passed')
-  }
-
-  for (let i = 0; i < n; ++i) {
-    const entry = fns[i]
-    if (Array.isArray(entry)) {
-      const fn = entry[0]
-      const args = entry.slice()
-      args[0] = undefined
-      fns[i] = function composeWithArgs(value) {
-        args[0] = value
-        try {
-          return fn.apply(this, args)
-        } finally {
-          args[0] = undefined
-        }
-      }
-    }
-  }
-
-  if (n === 1) {
-    return fns[0]
-  }
-
-  if (opts.right) {
-    fns.reverse()
-  }
-
-  return opts.async
-    ? async function () {
-        let value = await fns[0].apply(this, arguments)
-        for (let i = 1; i < n; ++i) {
-          value = await fns[i].call(this, value)
-        }
-        return value
-      }
-    : function () {
-        let value = fns[0].apply(this, arguments)
-        for (let i = 1; i < n; ++i) {
-          value = fns[i].call(this, value)
-        }
-        return value
-      }
-}

@vates/compose/index.spec.js

@@ -1,68 +0,0 @@
-'use strict'
-
-/* eslint-env jest */
-
-const { compose } = require('./')
-
-const add2 = x => x + 2
-const mul3 = x => x * 3
-
-describe('compose()', () => {
-  it('throws when no functions is passed', () => {
-    expect(() => compose()).toThrow(TypeError)
-    expect(() => compose([])).toThrow(TypeError)
-  })
-
-  it('applies from left to right', () => {
-    expect(compose(add2, mul3)(5)).toBe(21)
-  })
-
-  it('accepts functions in an array', () => {
-    expect(compose([add2, mul3])(5)).toBe(21)
-  })
-
-  it('can apply from right to left', () => {
-    expect(compose({ right: true }, add2, mul3)(5)).toBe(17)
-  })
-
-  it('accepts options with functions in an array', () => {
-    expect(compose({ right: true }, [add2, mul3])(5)).toBe(17)
-  })
-
-  it('can compose async functions', async () => {
-    expect(
-      await compose(
-        { async: true },
-        async x => x + 2,
-        async x => x * 3
-      )(5)
-    ).toBe(21)
-  })
-
-  it('forwards all args to first function', () => {
-    expect.assertions(1)
-
-    const expectedArgs = [Math.random(), Math.random()]
-    compose(
-      (...args) => {
-        expect(args).toEqual(expectedArgs)
-      },
-      // add a second function to avoid the one function special case
-      Function.prototype
-    )(...expectedArgs)
-  })
-
-  it('forwards context to all functions', () => {
-    expect.assertions(2)
-
-    const expectedThis = {}
-    compose(
-      function () {
-        expect(this).toBe(expectedThis)
-      },
-      function () {
-        expect(this).toBe(expectedThis)
-      }
-    ).call(expectedThis)
-  })
-})

@vates/compose/package.json

@@ -1,24 +0,0 @@
-{
-  "private": false,
-  "name": "@vates/compose",
-  "description": "Compose functions from left to right",
-  "homepage": "https://github.com/vatesfr/xen-orchestra/tree/master/@vates/compose",
-  "bugs": "https://github.com/vatesfr/xen-orchestra/issues",
-  "repository": {
-    "directory": "@vates/compose",
-    "type": "git",
-    "url": "https://github.com/vatesfr/xen-orchestra.git"
-  },
-  "author": {
-    "name": "Vates SAS",
-    "url": "https://vates.fr"
-  },
-  "license": "ISC",
-  "version": "2.1.0",
-  "engines": {
-    "node": ">=7.6"
-  },
-  "scripts": {
-    "postversion": "npm publish --access public"
-  }
-}

@vates/decorate-with/.USAGE.md

@@ -1,86 +0,0 @@
-### `decorateWith(fn, ...args)`
-
-Creates a new ([legacy](https://babeljs.io/docs/en/babel-plugin-syntax-decorators#legacy)) method decorator from a function decorator, for instance, allows using Lodash's functions as decorators:
-
-```js
-import { decorateWith } from '@vates/decorate-with'
-
-class Foo {
-  @decorateWith(lodash.debounce, 150)
-  bar() {
-    // body
-  }
-}
-```
-
-### `decorateClass(class, map)`
-
-Decorates a number of accessors and methods directly, without using the decorator syntax:
-
-```js
-import { decorateClass } from '@vates/decorate-with'
-
-class Foo {
-  get bar() {
-    // body
-  }
-
-  set bar(value) {
-    // body
-  }
-
-  baz() {
-    // body
-  }
-}
-
-decorateClass(Foo, {
-  // getter and/or setter
-  bar: {
-    // without arguments
-    get: lodash.memoize,
-
-    // with arguments
-    set: [lodash.debounce, 150],
-  },
-
-  // method (with or without arguments)
-  baz: lodash.curry,
-})
-```
-
-The decorated class is returned, so you can export it directly.
-
-To apply multiple transforms to an accessor/method, you can either call `decorateClass` multiple times or use [`@vates/compose`](https://www.npmjs.com/package/@vates/compose):
-
-```js
-decorateClass(Foo, {
-  baz: compose([
-    [lodash.debounce, 150]
-    lodash.curry,
-  ])
-})
-```
-
-### `perInstance(fn, ...args)`
-
-Helper to decorate the method by instance instead of for the whole class.
-
-This is often necessary for caching or deduplicating calls.
-
-```js
-import { perInstance } from '@vates/decorateWith'
-
-class Foo {
-  @decorateWith(perInstance, lodash.memoize)
-  bar() {
-    // body
-  }
-}
-```
-
-Because it's a normal function, it can also be used with `decorateClass`, with `compose` or even by itself.
-
-### `decorateMethodsWith(class, map)`
-
-> Deprecated alias for [`decorateClass(class, map)`](#decorateclassclass-map).

@vates/decorate-with/.npmignore

@@ -1 +0,0 @@
-../../scripts/npmignore

@vates/decorate-with/README.md

@@ -1,119 +0,0 @@
-<!-- DO NOT EDIT MANUALLY, THIS FILE HAS BEEN GENERATED -->
-
-# @vates/decorate-with
-
-[![Package Version](https://badgen.net/npm/v/@vates/decorate-with)](https://npmjs.org/package/@vates/decorate-with) ![License](https://badgen.net/npm/license/@vates/decorate-with) [![PackagePhobia](https://badgen.net/bundlephobia/minzip/@vates/decorate-with)](https://bundlephobia.com/result?p=@vates/decorate-with) [![Node compatibility](https://badgen.net/npm/node/@vates/decorate-with)](https://npmjs.org/package/@vates/decorate-with)
-
-> Creates a decorator from a function wrapper
-
-## Install
-
-Installation of the [npm package](https://npmjs.org/package/@vates/decorate-with):
-
-```
-> npm install --save @vates/decorate-with
-```
-
-## Usage
-
-### `decorateWith(fn, ...args)`
-
-Creates a new ([legacy](https://babeljs.io/docs/en/babel-plugin-syntax-decorators#legacy)) method decorator from a function decorator, for instance, allows using Lodash's functions as decorators:
-
-```js
-import { decorateWith } from '@vates/decorate-with'
-
-class Foo {
-  @decorateWith(lodash.debounce, 150)
-  bar() {
-    // body
-  }
-}
-```
-
-### `decorateClass(class, map)`
-
-Decorates a number of accessors and methods directly, without using the decorator syntax:
-
-```js
-import { decorateClass } from '@vates/decorate-with'
-
-class Foo {
-  get bar() {
-    // body
-  }
-
-  set bar(value) {
-    // body
-  }
-
-  baz() {
-    // body
-  }
-}
-
-decorateClass(Foo, {
-  // getter and/or setter
-  bar: {
-    // without arguments
-    get: lodash.memoize,
-
-    // with arguments
-    set: [lodash.debounce, 150],
-  },
-
-  // method (with or without arguments)
-  baz: lodash.curry,
-})
-```
-
-The decorated class is returned, so you can export it directly.
-
-To apply multiple transforms to an accessor/method, you can either call `decorateClass` multiple times or use [`@vates/compose`](https://www.npmjs.com/package/@vates/compose):
-
-```js
-decorateClass(Foo, {
-  baz: compose([
-    [lodash.debounce, 150]
-    lodash.curry,
-  ])
-})
-```
-
-### `perInstance(fn, ...args)`
-
-Helper to decorate the method by instance instead of for the whole class.
-
-This is often necessary for caching or deduplicating calls.
-
-```js
-import { perInstance } from '@vates/decorateWith'
-
-class Foo {
-  @decorateWith(perInstance, lodash.memoize)
-  bar() {
-    // body
-  }
-}
-```
-
-Because it's a normal function, it can also be used with `decorateClass`, with `compose` or even by itself.
-
-### `decorateMethodsWith(class, map)`
-
-> Deprecated alias for [`decorateClass(class, map)`](#decorateclassclass-map).
-
-## Contributions
-
-Contributions are _very_ welcomed, either on the documentation or on
-the code.
-
-You may:
-
-- report any [issue](https://github.com/vatesfr/xen-orchestra/issues)
-  you've encountered;
-- fork and create a pull request.
-
-## License
-
-[ISC](https://spdx.org/licenses/ISC) © [Vates SAS](https://vates.fr)

@vates/decorate-with/index.js

@@ -1,48 +0,0 @@
-'use strict'
-
-exports.decorateWith = function decorateWith(fn, ...args) {
-  return (target, name, descriptor) => ({
-    ...descriptor,
-    value: fn(descriptor.value, ...args),
-  })
-}
-
-const { getOwnPropertyDescriptor, defineProperty } = Object
-
-function applyDecorator(decorator, value) {
-  return typeof decorator === 'function' ? decorator(value) : decorator[0](value, ...decorator.slice(1))
-}
-
-exports.decorateClass = exports.decorateMethodsWith = function decorateClass(klass, map) {
-  const { prototype } = klass
-  for (const name of Object.keys(map)) {
-    const decorator = map[name]
-    const descriptor = getOwnPropertyDescriptor(prototype, name)
-    if (typeof decorator === 'function' || Array.isArray(decorator)) {
-      descriptor.value = applyDecorator(decorator, descriptor.value)
-    } else {
-      const { get, set } = decorator
-      if (get !== undefined) {
-        descriptor.get = applyDecorator(get, descriptor.get)
-      }
-      if (set !== undefined) {
-        descriptor.set = applyDecorator(set, descriptor.set)
-      }
-    }
-
-    defineProperty(prototype, name, descriptor)
-  }
-  return klass
-}
-
-exports.perInstance = function perInstance(fn, decorator, ...args) {
-  const map = new WeakMap()
-  return function () {
-    let decorated = map.get(this)
-    if (decorated === undefined) {
-      decorated = decorator(fn, ...args)
-      map.set(this, decorated)
-    }
-    return decorated.apply(this, arguments)
-  }
-}

@vates/decorate-with/index.spec.js

@@ -1,152 +0,0 @@
-'use strict'
-
-const assert = require('assert')
-const { describe, it } = require('tap').mocha
-
-const { decorateClass, decorateWith, decorateMethodsWith, perInstance } = require('./')
-
-const identity = _ => _
-
-describe('decorateWith', () => {
-  it('works', () => {
-    const expectedArgs = [Math.random(), Math.random()]
-    const expectedFn = Function.prototype
-    const newFn = () => {}
-
-    const decorator = decorateWith(function wrapper(fn, ...args) {
-      assert.deepStrictEqual(fn, expectedFn)
-      assert.deepStrictEqual(args, expectedArgs)
-
-      return newFn
-    }, ...expectedArgs)
-
-    const descriptor = {
-      configurable: true,
-      enumerable: false,
-      value: expectedFn,
-      writable: true,
-    }
-    assert.deepStrictEqual(decorator({}, 'foo', descriptor), {
-      ...descriptor,
-      value: newFn,
-    })
-  })
-})
-
-describe('decorateClass', () => {
-  it('works', () => {
-    class C {
-      foo() {}
-      bar() {}
-      get baz() {}
-      // eslint-disable-next-line accessor-pairs
-      set qux(_) {}
-    }
-
-    const expectedArgs = [Math.random(), Math.random()]
-    const P = C.prototype
-
-    const descriptors = Object.getOwnPropertyDescriptors(P)
-
-    const newFoo = () => {}
-    const newBar = () => {}
-    const newGetBaz = () => {}
-    const newSetQux = _ => {}
-
-    decorateClass(C, {
-      foo(fn) {
-        assert.strictEqual(arguments.length, 1)
-        assert.strictEqual(fn, P.foo)
-        return newFoo
-      },
-      bar: [
-        function (fn, ...args) {
-          assert.strictEqual(fn, P.bar)
-          assert.deepStrictEqual(args, expectedArgs)
-          return newBar
-        },
-        ...expectedArgs,
-      ],
-      baz: {
-        get(fn) {
-          assert.strictEqual(arguments.length, 1)
-          assert.strictEqual(fn, descriptors.baz.get)
-          return newGetBaz
-        },
-      },
-      qux: {
-        set: [
-          function (fn, ...args) {
-            assert.strictEqual(fn, descriptors.qux.set)
-            assert.deepStrictEqual(args, expectedArgs)
-            return newSetQux
-          },
-          ...expectedArgs,
-        ],
-      },
-    })
-
-    const newDescriptors = Object.getOwnPropertyDescriptors(P)
-    assert.deepStrictEqual(newDescriptors.foo, { ...descriptors.foo, value: newFoo })
-    assert.deepStrictEqual(newDescriptors.bar, { ...descriptors.bar, value: newBar })
-    assert.deepStrictEqual(newDescriptors.baz, { ...descriptors.baz, get: newGetBaz })
-    assert.deepStrictEqual(newDescriptors.qux, { ...descriptors.qux, set: newSetQux })
-  })
-
-  it('throws if using an accessor decorator for a method', function () {
-    assert.throws(() =>
-      decorateClass(
-        class {
-          foo() {}
-        },
-        { foo: { get: identity, set: identity } }
-      )
-    )
-  })
-
-  it('throws if using a method decorator for an accessor', function () {
-    assert.throws(() =>
-      decorateClass(
-        class {
-          get foo() {}
-        },
-        { foo: identity }
-      )
-    )
-  })
-})
-
-it('decorateMethodsWith is an alias of decorateClass', function () {
-  assert.strictEqual(decorateMethodsWith, decorateClass)
-})
-
-describe('perInstance', () => {
-  it('works', () => {
-    let calls = 0
-
-    const expectedArgs = [Math.random(), Math.random()]
-    const expectedFn = Function.prototype
-    function wrapper(fn, ...args) {
-      assert.strictEqual(fn, expectedFn)
-      assert.deepStrictEqual(args, expectedArgs)
-      const i = ++calls
-      return () => i
-    }
-
-    const wrapped = perInstance(expectedFn, wrapper, ...expectedArgs)
-
-    // decorator is not called before decorated called
-    assert.strictEqual(calls, 0)
-
-    const o1 = {}
-    const o2 = {}
-
-    assert.strictEqual(wrapped.call(o1), 1)
-
-    // the same decorated function is returned for the same instance
-    assert.strictEqual(wrapped.call(o1), 1)
-
-    // a new decorated function is returned for another instance
-    assert.strictEqual(wrapped.call(o2), 2)
-  })
-})

@vates/decorate-with/package.json

@@ -1,34 +0,0 @@
-{
-  "private": false,
-  "name": "@vates/decorate-with",
-  "description": "Creates a decorator from a function wrapper",
-  "keywords": [
-    "apply",
-    "decorator",
-    "factory",
-    "wrapper"
-  ],
-  "homepage": "https://github.com/vatesfr/xen-orchestra/tree/master/@vates/decorate-with",
-  "bugs": "https://github.com/vatesfr/xen-orchestra/issues",
-  "repository": {
-    "directory": "@vates/decorate-with",
-    "type": "git",
-    "url": "https://github.com/vatesfr/xen-orchestra.git"
-  },
-  "author": {
-    "name": "Vates SAS",
-    "url": "https://vates.fr"
-  },
-  "license": "ISC",
-  "version": "2.0.0",
-  "engines": {
-    "node": ">=8.10"
-  },
-  "scripts": {
-    "postversion": "npm publish --access public",
-    "test": "tap"
-  },
-  "devDependencies": {
-    "tap": "^16.0.1"
-  }
-}

@vates/disposable/.USAGE.md

@@ -1,56 +0,0 @@
-This library contains utilities for disposables as defined by the [`promise-toolbox` library](https://github.com/JsCommunity/promise-toolbox#resource-management).
-
-### `deduped(fn, keyFn)`
-
-Creates a new function that wraps `fn` and instead of creating a new disposables at each call, returns copies of the same one when `keyFn` returns the same keys.
-
-Those copies contains the same value and can be disposed independently, the source disposable will only be disposed when all copies are disposed.
-
-`keyFn` is called with the same context and arguments as the wrapping function and must returns an array of keys which will be used to identify which disposables should be grouped together.
-
-```js
-import { deduped } from '@vates/disposable/deduped'
-
-// the connection with the passed host will be established once at the first call, then, it will be shared with the next calls
-const getConnection = deduped(async function (host)) {
-  const connection = new Connection(host)
-  return new Disposabe(connection, () => connection.close())
-}, host => [host])
-```
-
-### `debounceResource(disposable, delay)`
-
-Creates a new disposable with the same value and with a delayed disposer.
-
-On calling this disposer, the source disposable will be disposed when the `delay` is passed.
-
-```js
-import { createDebounceResource } from '@vates/disposable/debounceResource'
-
-const debounceResource = createDebounceResource()
-
-// it will wait for 10 seconds before calling the disposer
-Disposable.use(debounceResource(getConnection(host), 10e3), connection => {})
-```
-
-### `debounceResource.flushAll()`
-
-Disposes all delayed disposers and cancels the delaying of the disposables that are in usage.
-
-```js
-import { createDebounceResource } from '@vates/disposable/debounceResource'
-
-const debounceResource = createDebounceResource()
-
-const res1 = await debounceResource(res, 10e3)
-const res2 = await debounceResource(res, 10e3)
-const res3 = await debounceResource(res, 10e3)
-
-rest1.dispose()
-rest2.dispose()
-// res3 is in usage
-
-debounceResource.flushAll()
-// res1 and res2 are immediately disposed
-// res3 will be disposed immediately when its disposer will be called
-```

@vates/disposable/.npmignore

@@ -1 +0,0 @@
-../../scripts/npmignore

@vates/disposable/README.md

@@ -1,89 +0,0 @@
-<!-- DO NOT EDIT MANUALLY, THIS FILE HAS BEEN GENERATED -->
-
-# @vates/disposable
-
-[![Package Version](https://badgen.net/npm/v/@vates/disposable)](https://npmjs.org/package/@vates/disposable) ![License](https://badgen.net/npm/license/@vates/disposable) [![PackagePhobia](https://badgen.net/bundlephobia/minzip/@vates/disposable)](https://bundlephobia.com/result?p=@vates/disposable) [![Node compatibility](https://badgen.net/npm/node/@vates/disposable)](https://npmjs.org/package/@vates/disposable)
-
-> Utilities for disposables
-
-## Install
-
-Installation of the [npm package](https://npmjs.org/package/@vates/disposable):
-
-```
-> npm install --save @vates/disposable
-```
-
-## Usage
-
-This library contains utilities for disposables as defined by the [`promise-toolbox` library](https://github.com/JsCommunity/promise-toolbox#resource-management).
-
-### `deduped(fn, keyFn)`
-
-Creates a new function that wraps `fn` and instead of creating a new disposables at each call, returns copies of the same one when `keyFn` returns the same keys.
-
-Those copies contains the same value and can be disposed independently, the source disposable will only be disposed when all copies are disposed.
-
-`keyFn` is called with the same context and arguments as the wrapping function and must returns an array of keys which will be used to identify which disposables should be grouped together.
-
-```js
-import { deduped } from '@vates/disposable/deduped'
-
-// the connection with the passed host will be established once at the first call, then, it will be shared with the next calls
-const getConnection = deduped(async function (host)) {
-  const connection = new Connection(host)
-  return new Disposabe(connection, () => connection.close())
-}, host => [host])
-```
-
-### `debounceResource(disposable, delay)`
-
-Creates a new disposable with the same value and with a delayed disposer.
-
-On calling this disposer, the source disposable will be disposed when the `delay` is passed.
-
-```js
-import { createDebounceResource } from '@vates/disposable/debounceResource'
-
-const debounceResource = createDebounceResource()
-
-// it will wait for 10 seconds before calling the disposer
-Disposable.use(debounceResource(getConnection(host), 10e3), connection => {})
-```
-
-### `debounceResource.flushAll()`
-
-Disposes all delayed disposers and cancels the delaying of the disposables that are in usage.
-
-```js
-import { createDebounceResource } from '@vates/disposable/debounceResource'
-
-const debounceResource = createDebounceResource()
-
-const res1 = await debounceResource(res, 10e3)
-const res2 = await debounceResource(res, 10e3)
-const res3 = await debounceResource(res, 10e3)
-
-rest1.dispose()
-rest2.dispose()
-// res3 is in usage
-
-debounceResource.flushAll()
-// res1 and res2 are immediately disposed
-// res3 will be disposed immediately when its disposer will be called
-```
-
-## Contributions
-
-Contributions are _very_ welcomed, either on the documentation or on
-the code.
-
-You may:
-
-- report any [issue](https://github.com/vatesfr/xen-orchestra/issues)
-  you've encountered;
-- fork and create a pull request.
-
-## License
-
-[ISC](https://spdx.org/licenses/ISC) © [Vates SAS](https://vates.fr)

@vates/disposable/debounceResource.js

@@ -1,58 +0,0 @@
-'use strict'
-
-const { asyncMap } = require('@xen-orchestra/async-map')
-const { createLogger } = require('@xen-orchestra/log')
-
-const { warn } = createLogger('vates:disposable:debounceResource')
-
-exports.createDebounceResource = () => {
-  const flushers = new Set()
-  async function debounceResource(pDisposable, delay = debounceResource.defaultDelay) {
-    if (delay === 0) {
-      return pDisposable
-    }
-
-    const disposable = await pDisposable
-
-    let timeoutId
-    const disposeWrapper = async () => {
-      if (timeoutId !== undefined) {
-        clearTimeout(timeoutId)
-        timeoutId = undefined
-        flushers.delete(flusher)
-
-        try {
-          await disposable.dispose()
-        } catch (error) {
-          warn(error)
-        }
-      }
-    }
-
-    const flusher = () => {
-      const shouldDisposeNow = timeoutId !== undefined
-      if (shouldDisposeNow) {
-        return disposeWrapper()
-      } else {
-        // will dispose ASAP
-        delay = 0
-      }
-    }
-    flushers.add(flusher)
-
-    return {
-      dispose() {
-        timeoutId = setTimeout(disposeWrapper, delay)
-      },
-      value: disposable.value,
-    }
-  }
-  debounceResource.flushAll = () => {
-    // iterate on a sync way in order to not remove a flusher added on processing flushers
-    const promise = asyncMap(flushers, flush => flush())
-    flushers.clear()
-    return promise
-  }
-
-  return debounceResource
-}

@vates/disposable/debounceResource.spec.js

@@ -1,31 +0,0 @@
-'use strict'
-
-/* eslint-env jest */
-
-const { createDebounceResource } = require('./debounceResource')
-
-jest.useFakeTimers()
-
-describe('debounceResource()', () => {
-  it('calls the resource disposer after 10 seconds', async () => {
-    const debounceResource = createDebounceResource()
-    const delay = 10e3
-    const dispose = jest.fn()
-
-    const resource = await debounceResource(
-      Promise.resolve({
-        value: '',
-        dispose,
-      }),
-      delay
-    )
-
-    resource.dispose()
-
-    expect(dispose).not.toBeCalled()
-
-    jest.advanceTimersByTime(delay)
-
-    expect(dispose).toBeCalled()
-  })
-})

@vates/disposable/deduped.js

@@ -1,54 +0,0 @@
-'use strict'
-
-const ensureArray = require('ensure-array')
-const { MultiKeyMap } = require('@vates/multi-key-map')
-
-function State(factory) {
-  this.factory = factory
-  this.users = 0
-}
-
-const call = fn => fn()
-
-exports.deduped = (factory, keyFn = (...args) => args) =>
-  (function () {
-    const states = new MultiKeyMap()
-    return function () {
-      const keys = ensureArray(keyFn.apply(this, arguments))
-      let state = states.get(keys)
-      if (state === undefined) {
-        const result = factory.apply(this, arguments)
-
-        const createFactory = disposable => {
-          const wrapper = {
-            dispose() {
-              if (--state.users === 0) {
-                states.delete(keys)
-                return disposable.dispose()
-              }
-            },
-            value: disposable.value,
-          }
-
-          return () => {
-            return wrapper
-          }
-        }
-
-        if (typeof result.then !== 'function') {
-          state = new State(createFactory(result))
-        } else {
-          result.catch(() => {
-            states.delete(keys)
-          })
-          const pFactory = result.then(createFactory)
-          state = new State(() => pFactory.then(call))
-        }
-
-        states.set(keys, state)
-      }
-
-      ++state.users
-      return state.factory()
-    }
-  })()

@vates/disposable/deduped.spec.js

@@ -1,78 +0,0 @@
-'use strict'
-
-/* eslint-env jest */
-
-const { deduped } = require('./deduped')
-
-describe('deduped()', () => {
-  it('calls the resource function only once', async () => {
-    const value = {}
-    const getResource = jest.fn(async () => ({
-      value,
-      dispose: Function.prototype,
-    }))
-
-    const dedupedGetResource = deduped(getResource)
-
-    const { value: v1 } = await dedupedGetResource()
-    const { value: v2 } = await dedupedGetResource()
-
-    expect(getResource).toHaveBeenCalledTimes(1)
-    expect(v1).toBe(value)
-    expect(v2).toBe(value)
-  })
-
-  it('only disposes the source disposable when its all copies dispose', async () => {
-    const dispose = jest.fn()
-    const getResource = async () => ({
-      value: '',
-      dispose,
-    })
-
-    const dedupedGetResource = deduped(getResource)
-
-    const { dispose: d1 } = await dedupedGetResource()
-    const { dispose: d2 } = await dedupedGetResource()
-
-    d1()
-
-    expect(dispose).not.toHaveBeenCalled()
-
-    d2()
-
-    expect(dispose).toHaveBeenCalledTimes(1)
-  })
-
-  it('works with sync factory', () => {
-    const value = {}
-    const dispose = jest.fn()
-    const dedupedGetResource = deduped(() => ({ value, dispose }))
-
-    const d1 = dedupedGetResource()
-    expect(d1.value).toBe(value)
-
-    const d2 = dedupedGetResource()
-    expect(d2.value).toBe(value)
-
-    d1.dispose()
-
-    expect(dispose).not.toHaveBeenCalled()
-
-    d2.dispose()
-
-    expect(dispose).toHaveBeenCalledTimes(1)
-  })
-
-  it('no race condition on dispose before async acquisition', async () => {
-    const dispose = jest.fn()
-    const dedupedGetResource = deduped(async () => ({ value: 42, dispose }))
-
-    const d1 = await dedupedGetResource()
-
-    dedupedGetResource()
-
-    d1.dispose()
-
-    expect(dispose).not.toHaveBeenCalled()
-  })
-})

@vates/disposable/package.json

@@ -1,30 +0,0 @@
-{
-  "private": false,
-  "name": "@vates/disposable",
-  "homepage": "https://github.com/vatesfr/xen-orchestra/tree/master/@vates/disposable",
-  "description": "Utilities for disposables",
-  "bugs": "https://github.com/vatesfr/xen-orchestra/issues",
-  "repository": {
-    "directory": "@vates/disposable",
-    "type": "git",
-    "url": "https://github.com/vatesfr/xen-orchestra.git"
-  },
-  "author": {
-    "name": "Vates SAS",
-    "url": "https://vates.fr"
-  },
-  "license": "ISC",
-  "version": "0.1.1",
-  "engines": {
-    "node": ">=8.10"
-  },
-  "scripts": {
-    "postversion": "npm publish --access public"
-  },
-  "dependencies": {
-    "@vates/multi-key-map": "^0.1.0",
-    "@xen-orchestra/async-map": "^0.1.2",
-    "@xen-orchestra/log": "^0.3.0",
-    "ensure-array": "^1.0.0"
-  }
-}

@vates/event-listeners-manager/.USAGE.md

@@ -1,50 +0,0 @@
-> This library is compatible with Node's `EventEmitter` and web browsers' `EventTarget` APIs.
-
-### API
-
-```js
-import { EventListenersManager } from '@vates/event-listeners-manager'
-
-const events = new EventListenersManager(emitter)
-
-// adding listeners
-events.add('foo', onFoo).add('bar', onBar).on('baz', onBaz)
-
-// removing a specific listener
-events.remove('foo', onFoo)
-
-// removing all listeners for a specific event
-events.removeAll('foo')
-
-// removing all listeners
-events.removeAll()
-```
-
-### Typical use case
-
-> Removing all listeners when no longer necessary.
-
-Manually:
-
-```js
-const onFoo = () => {}
-const onBar = () => {}
-const onBaz = () => {}
-emitter.on('foo', onFoo).on('bar', onBar).on('baz', onBaz)
-
-// CODE LOGIC
-
-emitter.off('foo', onFoo).off('bar', onBar).off('baz', onBaz)
-```
-
-With this library:
-
-```js
-const events = new EventListenersManager(emitter)
-
-events.add('foo', () => {})).add('bar', () => {})).add('baz', () => {}))
-
-// CODE LOGIC
-
-events.removeAll()
-```

@vates/event-listeners-manager/.npmignore

@@ -1 +0,0 @@
-../../scripts/npmignore

@vates/event-listeners-manager/README.md

@@ -1,81 +0,0 @@
-<!-- DO NOT EDIT MANUALLY, THIS FILE HAS BEEN GENERATED -->
-
-# @vates/event-listeners-manager
-
-[![Package Version](https://badgen.net/npm/v/@vates/event-listeners-manager)](https://npmjs.org/package/@vates/event-listeners-manager) ![License](https://badgen.net/npm/license/@vates/event-listeners-manager) [![PackagePhobia](https://badgen.net/bundlephobia/minzip/@vates/event-listeners-manager)](https://bundlephobia.com/result?p=@vates/event-listeners-manager) [![Node compatibility](https://badgen.net/npm/node/@vates/event-listeners-manager)](https://npmjs.org/package/@vates/event-listeners-manager)
-
-## Install
-
-Installation of the [npm package](https://npmjs.org/package/@vates/event-listeners-manager):
-
-```
-> npm install --save @vates/event-listeners-manager
-```
-
-## Usage
-
-> This library is compatible with Node's `EventEmitter` and web browsers' `EventTarget` APIs.
-
-### API
-
-```js
-import { EventListenersManager } from '@vates/event-listeners-manager'
-
-const events = new EventListenersManager(emitter)
-
-// adding listeners
-events.add('foo', onFoo).add('bar', onBar).on('baz', onBaz)
-
-// removing a specific listener
-events.remove('foo', onFoo)
-
-// removing all listeners for a specific event
-events.removeAll('foo')
-
-// removing all listeners
-events.removeAll()
-```
-
-### Typical use case
-
-> Removing all listeners when no longer necessary.
-
-Manually:
-
-```js
-const onFoo = () => {}
-const onBar = () => {}
-const onBaz = () => {}
-emitter.on('foo', onFoo).on('bar', onBar).on('baz', onBaz)
-
-// CODE LOGIC
-
-emitter.off('foo', onFoo).off('bar', onBar).off('baz', onBaz)
-```
-
-With this library:
-
-```js
-const events = new EventListenersManager(emitter)
-
-events.add('foo', () => {})).add('bar', () => {})).add('baz', () => {}))
-
-// CODE LOGIC
-
-events.removeAll()
-```
-
-## Contributions
-
-Contributions are _very_ welcomed, either on the documentation or on
-the code.
-
-You may:
-
-- report any [issue](https://github.com/vatesfr/xen-orchestra/issues)
-  you've encountered;
-- fork and create a pull request.
-
-## License
-
-[ISC](https://spdx.org/licenses/ISC) © [Vates SAS](https://vates.fr)

@vates/event-listeners-manager/index.js

@@ -1,56 +0,0 @@
-'use strict'
-
-exports.EventListenersManager = class EventListenersManager {
-  constructor(emitter) {
-    this._listeners = new Map()
-
-    this._add = (emitter.addListener || emitter.addEventListener).bind(emitter)
-    this._remove = (emitter.removeListener || emitter.removeEventListener).bind(emitter)
-  }
-
-  add(type, listener) {
-    let listeners = this._listeners.get(type)
-    if (listeners === undefined) {
-      listeners = new Set()
-      this._listeners.set(type, listeners)
-    }
-
-    // don't add the same listener multiple times (allowed on Node.js)
-    if (!listeners.has(listener)) {
-      listeners.add(listener)
-      this._add(type, listener)
-    }
-
-    return this
-  }
-
-  remove(type, listener) {
-    const allListeners = this._listeners
-    const listeners = allListeners.get(type)
-    if (listeners !== undefined && listeners.delete(listener)) {
-      this._remove(type, listener)
-      if (listeners.size === 0) {
-        allListeners.delete(type)
-      }
-    }
-
-    return this
-  }
-
-  removeAll(type) {
-    const allListeners = this._listeners
-    const remove = this._remove
-    const types = type !== undefined ? [type] : allListeners.keys()
-    for (const type of types) {
-      const listeners = allListeners.get(type)
-      if (listeners !== undefined) {
-        allListeners.delete(type)
-        for (const listener of listeners) {
-          remove(type, listener)
-        }
-      }
-    }
-
-    return this
-  }
-}

@vates/event-listeners-manager/index.spec.js

@@ -1,67 +0,0 @@
-'use strict'
-
-const t = require('tap')
-const { EventEmitter } = require('events')
-
-const { EventListenersManager } = require('./')
-
-const noop = Function.prototype
-
-// function spy (impl = Function.prototype) {
-//   function spy() {
-//     spy.calls.push([Array.from(arguments), this])
-//   }
-//   spy.calls = []
-//   return spy
-// }
-
-function assertListeners(t, event, listeners) {
-  t.strictSame(t.context.ee.listeners(event), listeners)
-}
-
-t.beforeEach(function (t) {
-  t.context.ee = new EventEmitter()
-  t.context.em = new EventListenersManager(t.context.ee)
-})
-
-t.test('.add adds a listener', function (t) {
-  t.context.em.add('foo', noop)
-
-  assertListeners(t, 'foo', [noop])
-
-  t.end()
-})
-
-t.test('.add does not add a duplicate listener', function (t) {
-  t.context.em.add('foo', noop).add('foo', noop)
-
-  assertListeners(t, 'foo', [noop])
-
-  t.end()
-})
-
-t.test('.remove removes a listener', function (t) {
-  t.context.em.add('foo', noop).remove('foo', noop)
-
-  assertListeners(t, 'foo', [])
-
-  t.end()
-})
-
-t.test('.removeAll removes all listeners of a given type', function (t) {
-  t.context.em.add('foo', noop).add('bar', noop).removeAll('foo')
-
-  assertListeners(t, 'foo', [])
-  assertListeners(t, 'bar', [noop])
-
-  t.end()
-})
-
-t.test('.removeAll removes all listeners', function (t) {
-  t.context.em.add('foo', noop).add('bar', noop).removeAll()
-
-  assertListeners(t, 'foo', [])
-  assertListeners(t, 'bar', [])
-
-  t.end()
-})

@vates/event-listeners-manager/package.json

@@ -1,46 +0,0 @@
-{
-  "engines": {
-    "node": ">=6"
-  },
-  "private": false,
-  "name": "@vates/event-listeners-manager",
-  "descriptions": "Easy way to clean up event listeners",
-  "keywords": [
-    "add",
-    "addEventListener",
-    "addListener",
-    "browser",
-    "clear",
-    "DOM",
-    "emitter",
-    "event",
-    "EventEmitter",
-    "EventTarget",
-    "management",
-    "manager",
-    "node",
-    "remove",
-    "removeEventListener",
-    "removeListener"
-  ],
-  "homepage": "https://github.com/vatesfr/xen-orchestra/tree/master/@vates/event-listeners-manager",
-  "bugs": "https://github.com/vatesfr/xen-orchestra/issues",
-  "repository": {
-    "directory": "@vates/event-listeners-manager",
-    "type": "git",
-    "url": "https://github.com/vatesfr/xen-orchestra.git"
-  },
-  "author": {
-    "name": "Vates SAS",
-    "url": "https://vates.fr"
-  },
-  "license": "ISC",
-  "version": "1.0.1",
-  "scripts": {
-    "postversion": "npm publish --access public",
-    "test": "tap --branches=72"
-  },
-  "devDependencies": {
-    "tap": "^16.2.0"
-  }
-}

@vates/fuse-vhd/.npmignore

@@ -1 +0,0 @@
-../../scripts/npmignore

@vates/fuse-vhd/index.js

@@ -1,71 +0,0 @@
-'use strict'
-
-const LRU = require('lru-cache')
-const Fuse = require('fuse-native')
-const { VhdSynthetic } = require('vhd-lib')
-const { Disposable, fromCallback } = require('promise-toolbox')
-const { createLogger } = require('@xen-orchestra/log')
-
-const { warn } = createLogger('vates:fuse-vhd')
-
-// build a s stat object from https://github.com/fuse-friends/fuse-native/blob/master/test/fixtures/stat.js
-const stat = st => ({
-  mtime: st.mtime || new Date(),
-  atime: st.atime || new Date(),
-  ctime: st.ctime || new Date(),
-  size: st.size !== undefined ? st.size : 0,
-  mode: st.mode === 'dir' ? 16877 : st.mode === 'file' ? 33188 : st.mode === 'link' ? 41453 : st.mode,
-  uid: st.uid !== undefined ? st.uid : process.getuid(),
-  gid: st.gid !== undefined ? st.gid : process.getgid(),
-})
-
-exports.mount = Disposable.factory(async function* mount(handler, diskPath, mountDir) {
-  const vhd = yield VhdSynthetic.fromVhdChain(handler, diskPath)
-
-  const cache = new LRU({
-    max: 16, // each cached block is 2MB in size
-  })
-  await vhd.readBlockAllocationTable()
-  const fuse = new Fuse(mountDir, {
-    async readdir(path, cb) {
-      if (path === '/') {
-        return cb(null, ['vhd0'])
-      }
-      cb(Fuse.ENOENT)
-    },
-    async getattr(path, cb) {
-      if (path === '/') {
-        return cb(
-          null,
-          stat({
-            mode: 'dir',
-            size: 4096,
-          })
-        )
-      }
-      if (path === '/vhd0') {
-        return cb(
-          null,
-          stat({
-            mode: 'file',
-            size: vhd.footer.currentSize,
-          })
-        )
-      }
-
-      cb(Fuse.ENOENT)
-    },
-    read(path, fd, buf, len, pos, cb) {
-      if (path === '/vhd0') {
-        return vhd
-          .readRawData(pos, len, cache, buf)
-          .then(cb)
-      }
-      throw new Error(`read file ${path} not exists`)
-    },
-  })
-  return new Disposable(
-    () => fromCallback(() => fuse.unmount()),
-    fromCallback(() => fuse.mount())
-    )
-})

@vates/fuse-vhd/package.json

@@ -1,30 +0,0 @@
-{
-  "name": "@vates/fuse-vhd",
-  "version": "0.0.1",
-  "license": "ISC",
-  "private": false,
-  "homepage": "https://github.com/vatesfr/xen-orchestra/tree/master/@vates/fuse-vhd",
-  "bugs": "https://github.com/vatesfr/xen-orchestra/issues",
-  "repository": {
-    "directory": "@vates/fuse-vhd",
-    "type": "git",
-    "url": "https://github.com/vatesfr/xen-orchestra.git"
-  },
-  "author": {
-    "name": "Vates SAS",
-    "url": "https://vates.fr"
-  },
-  "engines": {
-    "node": ">=10.0"
-  },
-  "dependencies": {
-    "@xen-orchestra/log": "^0.3.0",
-    "fuse-native": "^2.2.6",
-    "lru-cache": "^7.14.0",
-    "promise-toolbox": "^0.21.0",
-    "vhd-lib": "^4.0.1"
-  },
-  "scripts": {
-    "postversion": "npm publish --access public"
-  }
-}

@vates/multi-key-map/.USAGE.md

@@ -1,20 +0,0 @@
-```js
-import { MultiKeyMap } from '@vates/multi-key-map'
-
-const map = new MultiKeyMap()
-
-const OBJ = {}
-map.set([], 0)
-map.set(['foo'], 1)
-map.set(['foo', 'bar'], 2)
-map.set(['bar', 'foo'], 3)
-map.set([OBJ], 4)
-map.set([{}], 5)
-
-map.get([]) // 0
-map.get(['foo']) // 1
-map.get(['foo', 'bar']) // 2
-map.get(['bar', 'foo']) // 3
-map.get([OBJ]) // 4
-map.get([{}]) // undefined
-```

@vates/multi-key-map/.npmignore

@@ -1 +0,0 @@
-../../scripts/npmignore

@vates/multi-key-map/README.md

@@ -1,53 +0,0 @@
-<!-- DO NOT EDIT MANUALLY, THIS FILE HAS BEEN GENERATED -->
-
-# @vates/multi-key-map
-
-[![Package Version](https://badgen.net/npm/v/@vates/multi-key-map)](https://npmjs.org/package/@vates/multi-key-map) ![License](https://badgen.net/npm/license/@vates/multi-key-map) [![PackagePhobia](https://badgen.net/bundlephobia/minzip/@vates/multi-key-map)](https://bundlephobia.com/result?p=@vates/multi-key-map) [![Node compatibility](https://badgen.net/npm/node/@vates/multi-key-map)](https://npmjs.org/package/@vates/multi-key-map)
-
-> Create map with values affected to multiple keys
-
-## Install
-
-Installation of the [npm package](https://npmjs.org/package/@vates/multi-key-map):
-
-```
-> npm install --save @vates/multi-key-map
-```
-
-## Usage
-
-```js
-import { MultiKeyMap } from '@vates/multi-key-map'
-
-const map = new MultiKeyMap()
-
-const OBJ = {}
-map.set([], 0)
-map.set(['foo'], 1)
-map.set(['foo', 'bar'], 2)
-map.set(['bar', 'foo'], 3)
-map.set([OBJ], 4)
-map.set([{}], 5)
-
-map.get([]) // 0
-map.get(['foo']) // 1
-map.get(['foo', 'bar']) // 2
-map.get(['bar', 'foo']) // 3
-map.get([OBJ]) // 4
-map.get([{}]) // undefined
-```
-
-## Contributions
-
-Contributions are _very_ welcomed, either on the documentation or on
-the code.
-
-You may:
-
-- report any [issue](https://github.com/vatesfr/xen-orchestra/issues)
-  you've encountered;
-- fork and create a pull request.
-
-## License
-
-[ISC](https://spdx.org/licenses/ISC) © [Vates SAS](https://vates.fr)

@vates/multi-key-map/index.spec.js

@@ -1,36 +0,0 @@
-'use strict'
-
-/* eslint-env jest */
-
-const { MultiKeyMap } = require('./')
-
-describe('MultiKeyMap', () => {
-  it('works', () => {
-    const map = new MultiKeyMap()
-
-    const keys = [
-      // null key
-      [],
-      // simple key
-      ['foo'],
-      // composite key
-      ['foo', 'bar'],
-      // reverse composite key
-      ['bar', 'foo'],
-    ]
-    const values = keys.map(() => ({}))
-
-    // set all values first to make sure they are all stored and not only the
-    // last one
-    keys.forEach((key, i) => {
-      map.set(key, values[i])
-    })
-
-    keys.forEach((key, i) => {
-      // copy the key to make sure the array itself is not the key
-      expect(map.get(key.slice())).toBe(values[i])
-      map.delete(key.slice())
-      expect(map.get(key.slice())).toBe(undefined)
-    })
-  })
-})

@vates/multi-key-map/package.json

@@ -1,28 +0,0 @@
-{
-  "private": false,
-  "name": "@vates/multi-key-map",
-  "description": "Create map with values affected to multiple keys",
-  "keywords": [
-    "cache",
-    "map"
-  ],
-  "homepage": "https://github.com/vatesfr/xen-orchestra/tree/master/@vates/multi-key-map",
-  "bugs": "https://github.com/vatesfr/xen-orchestra/issues",
-  "repository": {
-    "directory": "@vates/multi-key-map",
-    "type": "git",
-    "url": "https://github.com/vatesfr/xen-orchestra.git"
-  },
-  "author": {
-    "name": "Vates SAS",
-    "url": "https://vates.fr"
-  },
-  "license": "ISC",
-  "version": "0.1.0",
-  "engines": {
-    "node": ">=8.10"
-  },
-  "scripts": {
-    "postversion": "npm publish --access public"
-  }
-}

@vates/parse-duration/.USAGE.md

@@ -1,14 +0,0 @@
-`ms` without magic: always parse a duration and throws if invalid.
-
-```js
-import { parseDuration } from '@vates/parse-duration'
-
-parseDuration('2 days')
-// 172800000
-
-parseDuration(172800000)
-// 172800000
-
-parseDuration(undefined)
-// throws TypeError('not a valid duration: undefined')
-```

@vates/parse-duration/.npmignore

@@ -1 +0,0 @@
-../../scripts/npmignore

@vates/parse-duration/README.md

@@ -1,47 +0,0 @@
-<!-- DO NOT EDIT MANUALLY, THIS FILE HAS BEEN GENERATED -->
-
-# @vates/parse-duration
-
-[![Package Version](https://badgen.net/npm/v/@vates/parse-duration)](https://npmjs.org/package/@vates/parse-duration) ![License](https://badgen.net/npm/license/@vates/parse-duration) [![PackagePhobia](https://badgen.net/bundlephobia/minzip/@vates/parse-duration)](https://bundlephobia.com/result?p=@vates/parse-duration) [![Node compatibility](https://badgen.net/npm/node/@vates/parse-duration)](https://npmjs.org/package/@vates/parse-duration)
-
-> Small wrapper around ms to parse a duration
-
-## Install
-
-Installation of the [npm package](https://npmjs.org/package/@vates/parse-duration):
-
-```
-> npm install --save @vates/parse-duration
-```
-
-## Usage
-
-`ms` without magic: always parse a duration and throws if invalid.
-
-```js
-import { parseDuration } from '@vates/parse-duration'
-
-parseDuration('2 days')
-// 172800000
-
-parseDuration(172800000)
-// 172800000
-
-parseDuration(undefined)
-// throws TypeError('not a valid duration: undefined')
-```
-
-## Contributions
-
-Contributions are _very_ welcomed, either on the documentation or on
-the code.
-
-You may:
-
-- report any [issue](https://github.com/vatesfr/xen-orchestra/issues)
-  you've encountered;
-- fork and create a pull request.
-
-## License
-
-[ISC](https://spdx.org/licenses/ISC) © [Vates SAS](https://vates.fr)

@vates/parse-duration/package.json

@@ -1,32 +0,0 @@
-{
-  "private": false,
-  "name": "@vates/parse-duration",
-  "description": "Small wrapper around ms to parse a duration",
-  "keywords": [
-    "duration",
-    "ms",
-    "parse"
-  ],
-  "homepage": "https://github.com/vatesfr/xen-orchestra/tree/master/@vates/parse-duration",
-  "bugs": "https://github.com/vatesfr/xen-orchestra/issues",
-  "repository": {
-    "directory": "@vates/parse-duration",
-    "type": "git",
-    "url": "https://github.com/vatesfr/xen-orchestra.git"
-  },
-  "author": {
-    "name": "Vates SAS",
-    "url": "https://vates.fr"
-  },
-  "license": "ISC",
-  "version": "0.1.1",
-  "engines": {
-    "node": ">=8.10"
-  },
-  "dependencies": {
-    "ms": "^2.1.2"
-  },
-  "scripts": {
-    "postversion": "npm publish --access public"
-  }
-}

@vates/predicates/.USAGE.md

@@ -1,57 +0,0 @@
-`undefined` predicates are ignored and `undefined` is returned if all predicates are `undefined`, this permits the most efficient composition:
-
-```js
-const compositePredicate = every(undefined, some(predicate2, undefined))
-
-// ends up as
-
-const compositePredicate = predicate2
-```
-
-Predicates can also be passed wrapped in an array:
-
-```js
-const compositePredicate = every([predicate1, some([predicate2, predicate3])])
-```
-
-`this` and all arguments are passed to the nested predicates.
-
-### `every(predicates)`
-
-> Returns a predicate that returns `true` iff every predicate returns `true`.
-
-```js
-const isBetween3And7 = every(
-  n => n >= 3,
-  n => n <= 7
-)
-
-isBetween3And10(0)
-// → false
-
-isBetween3And10(5)
-// → true
-
-isBetween3And10(10)
-// → false
-```
-
-### `some(predicates)`
-
-> Returns a predicate that returns `true` iff some predicate returns `true`.
-
-```js
-const isAliceOrBob = some(
-  name => name === 'Alice',
-  name => name === 'Bob'
-)
-
-isAliceOrBob('Alice')
-// → true
-
-isAliceOrBob('Bob')
-// → true
-
-isAliceOrBob('Oscar')
-// → false
-```

@vates/predicates/.npmignore

@@ -1 +0,0 @@
-../../scripts/npmignore

@vates/predicates/README.md

@@ -1,90 +0,0 @@
-<!-- DO NOT EDIT MANUALLY, THIS FILE HAS BEEN GENERATED -->
-
-# @vates/predicates
-
-[![Package Version](https://badgen.net/npm/v/@vates/predicates)](https://npmjs.org/package/@vates/predicates) ![License](https://badgen.net/npm/license/@vates/predicates) [![PackagePhobia](https://badgen.net/bundlephobia/minzip/@vates/predicates)](https://bundlephobia.com/result?p=@vates/predicates) [![Node compatibility](https://badgen.net/npm/node/@vates/predicates)](https://npmjs.org/package/@vates/predicates)
-
-> Utilities to compose predicates
-
-## Install
-
-Installation of the [npm package](https://npmjs.org/package/@vates/predicates):
-
-```
-> npm install --save @vates/predicates
-```
-
-## Usage
-
-`undefined` predicates are ignored and `undefined` is returned if all predicates are `undefined`, this permits the most efficient composition:
-
-```js
-const compositePredicate = every(undefined, some(predicate2, undefined))
-
-// ends up as
-
-const compositePredicate = predicate2
-```
-
-Predicates can also be passed wrapped in an array:
-
-```js
-const compositePredicate = every([predicate1, some([predicate2, predicate3])])
-```
-
-`this` and all arguments are passed to the nested predicates.
-
-### `every(predicates)`
-
-> Returns a predicate that returns `true` iff every predicate returns `true`.
-
-```js
-const isBetween3And7 = every(
-  n => n >= 3,
-  n => n <= 7
-)
-
-isBetween3And10(0)
-// → false
-
-isBetween3And10(5)
-// → true
-
-isBetween3And10(10)
-// → false
-```
-
-### `some(predicates)`
-
-> Returns a predicate that returns `true` iff some predicate returns `true`.
-
-```js
-const isAliceOrBob = some(
-  name => name === 'Alice',
-  name => name === 'Bob'
-)
-
-isAliceOrBob('Alice')
-// → true
-
-isAliceOrBob('Bob')
-// → true
-
-isAliceOrBob('Oscar')
-// → false
-```
-
-## Contributions
-
-Contributions are _very_ welcomed, either on the documentation or on
-the code.
-
-You may:
-
-- report any [issue](https://github.com/vatesfr/xen-orchestra/issues)
-  you've encountered;
-- fork and create a pull request.
-
-## License
-
-[ISC](https://spdx.org/licenses/ISC) © [Vates SAS](https://vates.fr)

@vates/predicates/index.js

@@ -1,71 +0,0 @@
-'use strict'
-
-const {
-  isArray,
-  prototype: { filter },
-} = Array
-
-class InvalidPredicate extends TypeError {
-  constructor(value) {
-    super('not a valid predicate')
-    this.value = value
-  }
-}
-
-function isDefinedPredicate(value) {
-  if (value === undefined) {
-    return false
-  }
-
-  if (typeof value !== 'function') {
-    throw new InvalidPredicate(value)
-  }
-
-  return true
-}
-
-function handleArgs() {
-  let predicates
-  if (!(arguments.length === 1 && isArray((predicates = arguments[0])))) {
-    predicates = arguments
-  }
-  return filter.call(predicates, isDefinedPredicate)
-}
-
-exports.every = function every() {
-  const predicates = handleArgs.apply(this, arguments)
-  const n = predicates.length
-  if (n === 0) {
-    return
-  }
-  if (n === 1) {
-    return predicates[0]
-  }
-  return function everyPredicate() {
-    for (let i = 0; i < n; ++i) {
-      if (!predicates[i].apply(this, arguments)) {
-        return false
-      }
-    }
-    return true
-  }
-}
-
-exports.some = function some() {
-  const predicates = handleArgs.apply(this, arguments)
-  const n = predicates.length
-  if (n === 0) {
-    return
-  }
-  if (n === 1) {
-    return predicates[0]
-  }
-  return function somePredicate() {
-    for (let i = 0; i < n; ++i) {
-      if (predicates[i].apply(this, arguments)) {
-        return true
-      }
-    }
-    return false
-  }
-}

@vates/predicates/index.spec.js

@@ -1,65 +0,0 @@
-'use strict'
-
-const assert = require('assert/strict')
-const { describe, it } = require('tap').mocha
-
-const { every, some } = require('./')
-
-const T = () => true
-const F = () => false
-
-const testArgsHandling = fn => {
-  it('returns undefined if all predicates are undefined', () => {
-    assert.equal(fn(undefined), undefined)
-    assert.equal(fn([undefined]), undefined)
-  })
-
-  it('returns the predicate if only a single one is passed', () => {
-    assert.equal(fn(undefined, T), T)
-    assert.equal(fn([undefined, T]), T)
-  })
-
-  it('throws if it receives a non-predicate', () => {
-    const error = new TypeError('not a valid predicate')
-    error.value = 3
-    assert.throws(() => fn(3), error)
-  })
-
-  it('forwards this and arguments to predicates', () => {
-    const thisArg = 'qux'
-    const args = ['foo', 'bar', 'baz']
-    const predicate = function () {
-      assert.equal(this, thisArg)
-      assert.deepEqual(Array.from(arguments), args)
-    }
-    fn(predicate, predicate).apply(thisArg, args)
-  })
-}
-
-const runTests = (fn, truthTable) =>
-  it('works', () => {
-    truthTable.forEach(([result, ...predicates]) => {
-      assert.equal(fn(...predicates)(), result)
-      assert.equal(fn(predicates)(), result)
-    })
-  })
-
-describe('every', () => {
-  testArgsHandling(every)
-  runTests(every, [
-    [true, T, T],
-    [false, T, F],
-    [false, F, T],
-    [false, F, F],
-  ])
-})
-
-describe('some', () => {
-  testArgsHandling(some)
-  runTests(some, [
-    [true, T, T],
-    [true, T, F],
-    [true, F, T],
-    [false, F, F],
-  ])
-})

@vates/predicates/package.json

@@ -1,40 +0,0 @@
-{
-  "private": false,
-  "name": "@vates/predicates",
-  "description": "Utilities to compose predicates",
-  "keywords": [
-    "and",
-    "combine",
-    "compose",
-    "every",
-    "function",
-    "functions",
-    "or",
-    "predicate",
-    "predicates",
-    "some"
-  ],
-  "homepage": "https://github.com/vatesfr/xen-orchestra/tree/master/@vates/predicates",
-  "bugs": "https://github.com/vatesfr/xen-orchestra/issues",
-  "repository": {
-    "directory": "@vates/predicates",
-    "type": "git",
-    "url": "https://github.com/vatesfr/xen-orchestra.git"
-  },
-  "author": {
-    "name": "Vates SAS",
-    "url": "https://vates.fr"
-  },
-  "license": "ISC",
-  "version": "1.0.0",
-  "engines": {
-    "node": ">=6"
-  },
-  "scripts": {
-    "postversion": "npm publish --access public",
-    "test": "tap"
-  },
-  "devDependencies": {
-    "tap": "^16.0.1"
-  }
-}

@vates/read-chunk/.USAGE.md

@@ -1,26 +0,0 @@
-### `readChunk(stream, [size])`
-
-- returns the next available chunk of data
-- like `stream.read()`, a number of bytes can be specified
-- returns with less data than expected if stream has ended
-- returns `null` if the stream has ended and no data has been read
-
-```js
-import { readChunk } from '@vates/read-chunk'
-;(async () => {
-  let chunk
-  while ((chunk = await readChunk(stream, 1024)) !== null) {
-    // do something with chunk
-  }
-})()
-```
-
-### `readChunkStrict(stream, [size])`
-
-Similar behavior to `readChunk` but throws if the stream ended before the requested data could be read.
-
-```js
-import { readChunkStrict } from '@vates/read-chunk'
-
-const chunk = await readChunkStrict(stream, 1024)
-```

@vates/read-chunk/.npmignore

@@ -1 +0,0 @@
-../../scripts/npmignore

@vates/read-chunk/README.md

@@ -1,59 +0,0 @@
-<!-- DO NOT EDIT MANUALLY, THIS FILE HAS BEEN GENERATED -->
-
-# @vates/read-chunk
-
-[![Package Version](https://badgen.net/npm/v/@vates/read-chunk)](https://npmjs.org/package/@vates/read-chunk) ![License](https://badgen.net/npm/license/@vates/read-chunk) [![PackagePhobia](https://badgen.net/bundlephobia/minzip/@vates/read-chunk)](https://bundlephobia.com/result?p=@vates/read-chunk) [![Node compatibility](https://badgen.net/npm/node/@vates/read-chunk)](https://npmjs.org/package/@vates/read-chunk)
-
-> Read a chunk of a Node stream
-
-## Install
-
-Installation of the [npm package](https://npmjs.org/package/@vates/read-chunk):
-
-```
-> npm install --save @vates/read-chunk
-```
-
-## Usage
-
-### `readChunk(stream, [size])`
-
-- returns the next available chunk of data
-- like `stream.read()`, a number of bytes can be specified
-- returns with less data than expected if stream has ended
-- returns `null` if the stream has ended and no data has been read
-
-```js
-import { readChunk } from '@vates/read-chunk'
-;(async () => {
-  let chunk
-  while ((chunk = await readChunk(stream, 1024)) !== null) {
-    // do something with chunk
-  }
-})()
-```
-
-### `readChunkStrict(stream, [size])`
-
-Similar behavior to `readChunk` but throws if the stream ended before the requested data could be read.
-
-```js
-import { readChunkStrict } from '@vates/read-chunk'
-
-const chunk = await readChunkStrict(stream, 1024)
-```
-
-## Contributions
-
-Contributions are _very_ welcomed, either on the documentation or on
-the code.
-
-You may:
-
-- report any [issue](https://github.com/vatesfr/xen-orchestra/issues)
-  you've encountered;
-- fork and create a pull request.
-
-## License
-
-[ISC](https://spdx.org/licenses/ISC) © [Vates SAS](https://vates.fr)

@vates/read-chunk/index.js

@@ -1,51 +0,0 @@
-'use strict'
-
-const readChunk = (stream, size) =>
-  size === 0
-    ? Promise.resolve(Buffer.alloc(0))
-    : new Promise((resolve, reject) => {
-        function onEnd() {
-          resolve(null)
-          removeListeners()
-        }
-        function onError(error) {
-          reject(error)
-          removeListeners()
-        }
-        function onReadable() {
-          const data = stream.read(size)
-          if (data !== null) {
-            resolve(data)
-            removeListeners()
-          }
-        }
-        function removeListeners() {
-          stream.removeListener('end', onEnd)
-          stream.removeListener('error', onError)
-          stream.removeListener('readable', onReadable)
-        }
-        stream.on('end', onEnd)
-        stream.on('error', onError)
-        stream.on('readable', onReadable)
-        onReadable()
-      })
-exports.readChunk = readChunk
-
-exports.readChunkStrict = async function readChunkStrict(stream, size) {
-  const chunk = await readChunk(stream, size)
-  if (chunk === null) {
-    throw new Error('stream has ended without data')
-  }
-
-  if (size !== undefined && chunk.length !== size) {
-    const error = new Error('stream has ended with not enough data')
-    Object.defineProperties(error, {
-      chunk: {
-        value: chunk,
-      },
-    })
-    throw error
-  }
-
-  return chunk
-}

@vates/read-chunk/index.spec.js

@@ -1,69 +0,0 @@
-'use strict'
-
-/* eslint-env jest */
-
-const { Readable } = require('stream')
-
-const { readChunk, readChunkStrict } = require('./')
-
-const makeStream = it => Readable.from(it, { objectMode: false })
-makeStream.obj = Readable.from
-
-describe('readChunk', () => {
-  it('returns null if stream is empty', async () => {
-    expect(await readChunk(makeStream([]))).toBe(null)
-  })
-
-  describe('with binary stream', () => {
-    it('returns the first chunk of data', async () => {
-      expect(await readChunk(makeStream(['foo', 'bar']))).toEqual(Buffer.from('foo'))
-    })
-
-    it('returns a chunk of the specified size (smaller than first)', async () => {
-      expect(await readChunk(makeStream(['foo', 'bar']), 2)).toEqual(Buffer.from('fo'))
-    })
-
-    it('returns a chunk of the specified size (larger than first)', async () => {
-      expect(await readChunk(makeStream(['foo', 'bar']), 4)).toEqual(Buffer.from('foob'))
-    })
-
-    it('returns less data if stream ends', async () => {
-      expect(await readChunk(makeStream(['foo', 'bar']), 10)).toEqual(Buffer.from('foobar'))
-    })
-
-    it('returns an empty buffer if the specified size is 0', async () => {
-      expect(await readChunk(makeStream(['foo', 'bar']), 0)).toEqual(Buffer.alloc(0))
-    })
-  })
-
-  describe('with object stream', () => {
-    it('returns the first chunk of data verbatim', async () => {
-      const chunks = [{}, {}]
-      expect(await readChunk(makeStream.obj(chunks))).toBe(chunks[0])
-    })
-  })
-})
-
-const rejectionOf = promise =>
-  promise.then(
-    value => {
-      throw value
-    },
-    error => error
-  )
-
-describe('readChunkStrict', function () {
-  it('throws if stream is empty', async () => {
-    const error = await rejectionOf(readChunkStrict(makeStream([])))
-    expect(error).toBeInstanceOf(Error)
-    expect(error.message).toBe('stream has ended without data')
-    expect(error.chunk).toEqual(undefined)
-  })
-
-  it('throws if stream ends with not enough data', async () => {
-    const error = await rejectionOf(readChunkStrict(makeStream(['foo', 'bar']), 10))
-    expect(error).toBeInstanceOf(Error)
-    expect(error.message).toBe('stream has ended with not enough data')
-    expect(error.chunk).toEqual(Buffer.from('foobar'))
-  })
-})

@vates/read-chunk/package.json

@@ -1,33 +0,0 @@
-{
-  "private": false,
-  "name": "@vates/read-chunk",
-  "homepage": "https://github.com/vatesfr/xen-orchestra/tree/master/@vates/read-chunk",
-  "description": "Read a chunk of a Node stream",
-  "license": "ISC",
-  "keywords": [
-    "async",
-    "chunk",
-    "data",
-    "node",
-    "promise",
-    "read",
-    "stream"
-  ],
-  "bugs": "https://github.com/vatesfr/xen-orchestra/issues",
-  "repository": {
-    "directory": "@vates/read-chunk",
-    "type": "git",
-    "url": "https://github.com/vatesfr/xen-orchestra.git"
-  },
-  "version": "1.0.0",
-  "engines": {
-    "node": ">=8.10"
-  },
-  "scripts": {
-    "postversion": "npm publish --access public"
-  },
-  "author": {
-    "name": "Vates SAS",
-    "url": "https://vates.fr"
-  }
-}

@vates/toggle-scripts/.USAGE.md

@@ -1,26 +0,0 @@
-```
-Usage: toggle-scripts options...
-
-  Easily enable/disable scripts in package.json
-
-  Options
-    +<script>    Enable the script <script>, ie remove the prefix `_`
-    -<script>    Disable the script <script>, ie prefix it with `_`
-
-  Examples
-    toggle-scripts +postinstall +preuninstall
-    toggle-scripts -postinstall -preuninstall
-```
-
-For example, if you want `postinstall` hook only in dev:
-
-```json
-// package.json
-{
-  "scripts": {
-    "postinstall": "<some dev only command>",
-    "prepublishOnly": "toggle-scripts -postinstall",
-    "postpublish": "toggle-scripts +postinstall"
-  }
-}
-```

@vates/toggle-scripts/.npmignore

@@ -1 +0,0 @@
-../../scripts/npmignore

@vates/toggle-scripts/README.md

@@ -1,59 +0,0 @@
-<!-- DO NOT EDIT MANUALLY, THIS FILE HAS BEEN GENERATED -->
-
-# @vates/toggle-scripts
-
-[![Package Version](https://badgen.net/npm/v/@vates/toggle-scripts)](https://npmjs.org/package/@vates/toggle-scripts) ![License](https://badgen.net/npm/license/@vates/toggle-scripts) [![PackagePhobia](https://badgen.net/bundlephobia/minzip/@vates/toggle-scripts)](https://bundlephobia.com/result?p=@vates/toggle-scripts) [![Node compatibility](https://badgen.net/npm/node/@vates/toggle-scripts)](https://npmjs.org/package/@vates/toggle-scripts)
-
-> Easily enable/disable scripts in package.json
-
-## Install
-
-Installation of the [npm package](https://npmjs.org/package/@vates/toggle-scripts):
-
-```
-> npm install --save @vates/toggle-scripts
-```
-
-## Usage
-
-```
-Usage: toggle-scripts options...
-
-  Easily enable/disable scripts in package.json
-
-  Options
-    +<script>    Enable the script <script>, ie remove the prefix `_`
-    -<script>    Disable the script <script>, ie prefix it with `_`
-
-  Examples
-    toggle-scripts +postinstall +preuninstall
-    toggle-scripts -postinstall -preuninstall
-```
-
-For example, if you want `postinstall` hook only in dev:
-
-```json
-// package.json
-{
-  "scripts": {
-    "postinstall": "<some dev only command>",
-    "prepublishOnly": "toggle-scripts -postinstall",
-    "postpublish": "toggle-scripts +postinstall"
-  }
-}
-```
-
-## Contributions
-
-Contributions are _very_ welcomed, either on the documentation or on
-the code.
-
-You may:
-
-- report any [issue](https://github.com/vatesfr/xen-orchestra/issues)
-  you've encountered;
-- fork and create a pull request.
-
-## License
-
-[ISC](https://spdx.org/licenses/ISC) © [Vates SAS](https://vates.fr)

@vates/toggle-scripts/index.js

@@ -1,62 +0,0 @@
-#!/usr/bin/env node
-
-'use strict'
-
-const fs = require('fs')
-
-const mapKeys = (object, iteratee) => {
-  const result = {}
-  for (const key of Object.keys(object)) {
-    result[iteratee(key, object)] = object[key]
-  }
-  return result
-}
-
-const args = process.argv.slice(2)
-if (args.length === 0) {
-  const { description, name, version } = require('./package.json')
-  const bin = 'toggle-scripts'
-  process.stdout.write(`Usage: ${bin} options...
-
-  ${description}
-
-  Options
-    +<script>    Enable the script <script>, ie remove the prefix \`_\`
-    -<script>    Disable the script <script>, ie prefix it with \`_\`
-
-  Examples
-    ${bin} +postinstall +preuninstall
-    ${bin} -postinstall -preuninstall
-
-${name} v${version}
-`)
-  process.exit()
-}
-
-const plan = { __proto__: null }
-for (const arg of args) {
-  const action = arg[0]
-  const script = arg.slice(1)
-
-  if (action === '+') {
-    plan['_' + script] = script
-  } else if (action === '-') {
-    plan[script] = '_' + script
-  } else {
-    throw new Error('invalid param: ' + arg)
-  }
-}
-
-const pkgPath = process.env.npm_package_json || './package.json'
-const pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf8'))
-pkg.scripts = mapKeys(pkg.scripts, (name, scripts) => {
-  const newName = plan[name]
-  if (newName === undefined) {
-    return name
-  }
-  if (newName in scripts) {
-    throw new Error('script already defined: ' + name)
-  }
-  return newName
-})
-fs.writeFileSync(pkgPath, JSON.stringify(pkg, null, 2) + '\n')

@vates/toggle-scripts/package.json

@@ -1,38 +0,0 @@
-{
-  "private": false,
-  "name": "@vates/toggle-scripts",
-  "description": "Easily enable/disable scripts in package.json",
-  "keywords": [
-    "dev",
-    "disable",
-    "enable",
-    "lifecycle",
-    "npm",
-    "package.json",
-    "pinst",
-    "postinstall",
-    "script",
-    "scripts",
-    "toggle"
-  ],
-  "homepage": "https://github.com/vatesfr/xen-orchestra/tree/master/@vates/toggle-scripts",
-  "bugs": "https://github.com/vatesfr/xen-orchestra/issues",
-  "repository": {
-    "directory": "@vates/toggle-scripts",
-    "type": "git",
-    "url": "https://github.com/vatesfr/xen-orchestra.git"
-  },
-  "author": {
-    "name": "Vates SAS",
-    "url": "https://vates.fr"
-  },
-  "license": "ISC",
-  "version": "1.0.0",
-  "engines": {
-    "node": ">=6"
-  },
-  "bin": "./index.js",
-  "scripts": {
-    "postversion": "npm publish --access public"
-  }
-}

@xen-orchestra/async-map/.USAGE.md

@@ -1,56 +0,0 @@
-### `asyncMap(iterable, iteratee, thisArg = iterable)`
-
-Similar to `Promise.all + Array#map` for all iterables: calls `iteratee` for each item in `iterable`, and returns a promise of an array containing the awaited result of each calls to `iteratee`.
-
-It rejects as soon as te first call to `iteratee` rejects.
-
-```js
-import { asyncMap } from '@xen-orchestra/async-map'
-
-const array = await asyncMap(iterable, iteratee, thisArg)
-```
-
-It can be used with any iterables (`Array`, `Map`, etc.):
-
-```js
-const map = new Map()
-map.set('foo', 42)
-map.set('bar', 3.14)
-
-const array = await asyncMap(map, async function ([key, value]) {
-  // TODO: do async computation
-  //
-  // the map can be accessed via `this`
-})
-```
-
-#### Use with plain objects
-
-Plain objects are not iterable, but you can use `Object.keys`, `Object.values` or `Object.entries` to help:
-
-```js
-const object = {
-  foo: 42,
-  bar: 3.14,
-}
-
-const array = await asyncMap(
-  Object.entries(object),
-  async function ([key, value]) {
-    // TODO: do async computation
-    //
-    // the object can be accessed via `this` because it's been passed as third arg
-  },
-  object
-)
-```
-
-### `asyncMapSettled(iterable, iteratee, thisArg = iterable)`
-
-Similar to `asyncMap` but waits for all promises to settle before rejecting.
-
-```js
-import { asyncMapSettled } from '@xen-orchestra/async-map'
-
-const array = await asyncMapSettled(iterable, iteratee, thisArg)
-```

@xen-orchestra/async-map/.babelrc.js

@@ -0,0 +1,3 @@
+module.exports = require('../../@xen-orchestra/babel-config')(
+  require('./package.json')
+)

@xen-orchestra/async-map/.npmignore

@@ -1 +0,0 @@
-../../scripts/npmignore

@xen-orchestra/async-map/.npmignore

@@ -0,0 +1,24 @@
+/benchmark/
+/benchmarks/
+*.bench.js
+*.bench.js.map
+
+/examples/
+example.js
+example.js.map
+*.example.js
+*.example.js.map
+
+/fixture/
+/fixtures/
+*.fixture.js
+*.fixture.js.map
+*.fixtures.js
+*.fixtures.js.map
+
+/test/
+/tests/
+*.spec.js
+*.spec.js.map
+
+__snapshots__/

@xen-orchestra/async-map/README.md

@@ -1,10 +1,6 @@
-<!-- DO NOT EDIT MANUALLY, THIS FILE HAS BEEN GENERATED -->
+# @xen-orchestra/async-map [![Build Status](https://travis-ci.org/vatesfr/xen-orchestra.png?branch=master)](https://travis-ci.org/vatesfr/xen-orchestra)
 
-# @xen-orchestra/async-map
-
-[![Package Version](https://badgen.net/npm/v/@xen-orchestra/async-map)](https://npmjs.org/package/@xen-orchestra/async-map) ![License](https://badgen.net/npm/license/@xen-orchestra/async-map) [![PackagePhobia](https://badgen.net/bundlephobia/minzip/@xen-orchestra/async-map)](https://bundlephobia.com/result?p=@xen-orchestra/async-map) [![Node compatibility](https://badgen.net/npm/node/@xen-orchestra/async-map)](https://npmjs.org/package/@xen-orchestra/async-map)
-
-> Promise.all + map for all iterables
+> ${pkg.description}
 
 ## Install
 
@@ -16,66 +12,30 @@ Installation of the [npm package](https://npmjs.org/package/@xen-orchestra/async
 
 ## Usage
 
-### `asyncMap(iterable, iteratee, thisArg = iterable)`
+**TODO**
 
-Similar to `Promise.all + Array#map` for all iterables: calls `iteratee` for each item in `iterable`, and returns a promise of an array containing the awaited result of each calls to `iteratee`.
+## Development
 
-It rejects as soon as te first call to `iteratee` rejects.
-
-```js
-import { asyncMap } from '@xen-orchestra/async-map'
-
-const array = await asyncMap(iterable, iteratee, thisArg)
 ```
+# Install dependencies
+> yarn
 
-It can be used with any iterables (`Array`, `Map`, etc.):
+# Run the tests
+> yarn test
 
-```js
-const map = new Map()
-map.set('foo', 42)
-map.set('bar', 3.14)
+# Continuously compile
+> yarn dev
 
-const array = await asyncMap(map, async function ([key, value]) {
-  // TODO: do async computation
-  //
-  // the map can be accessed via `this`
-})
-```
+# Continuously run the tests
+> yarn dev-test
 
-#### Use with plain objects
-
-Plain objects are not iterable, but you can use `Object.keys`, `Object.values` or `Object.entries` to help:
-
-```js
-const object = {
-  foo: 42,
-  bar: 3.14,
-}
-
-const array = await asyncMap(
-  Object.entries(object),
-  async function ([key, value]) {
-    // TODO: do async computation
-    //
-    // the object can be accessed via `this` because it's been passed as third arg
-  },
-  object
-)
-```
-
-### `asyncMapSettled(iterable, iteratee, thisArg = iterable)`
-
-Similar to `asyncMap` but waits for all promises to settle before rejecting.
-
-```js
-import { asyncMapSettled } from '@xen-orchestra/async-map'
-
-const array = await asyncMapSettled(iterable, iteratee, thisArg)
+# Build for production (automatically called by npm install)
+> yarn build
 ```
 
 ## Contributions
 
-Contributions are _very_ welcomed, either on the documentation or on
+Contributions are *very* welcomed, either on the documentation or on
 the code.
 
 You may:
@@ -86,4 +46,4 @@ You may:
 
 ## License
 
-[ISC](https://spdx.org/licenses/ISC) © [Vates SAS](https://vates.fr)
+ISC © [Vates SAS](https://vates.fr)

@xen-orchestra/async-map/index.js

@@ -1,73 +0,0 @@
-'use strict'
-
-const wrapCall = (fn, arg, thisArg) => {
-  try {
-    return Promise.resolve(fn.call(thisArg, arg))
-  } catch (error) {
-    return Promise.reject(error)
-  }
-}
-
-/**
- * Similar to Promise.all + Array#map but supports all iterables and does not trigger ESLint array-callback-return
- *
- * WARNING: Does not handle plain objects
- *
- * @template Item,This
- * @param {Iterable<Item>} iterable
- * @param {(this: This, item: Item) => (Item | PromiseLike<Item>)} mapFn
- * @param {This} [thisArg]
- * @returns {Promise<Item[]>}
- */
-exports.asyncMap = function asyncMap(iterable, mapFn, thisArg = iterable) {
-  return Promise.all(Array.from(iterable, mapFn, thisArg))
-}
-
-/**
- * Like `asyncMap` but wait for all promises to settle before rejecting
- *
- * @template Item,This
- * @param {Iterable<Item>} iterable
- * @param {(this: This, item: Item) => (Item | PromiseLike<Item>)} mapFn
- * @param {This} [thisArg]
- * @returns {Promise<Item[]>}
- */
-exports.asyncMapSettled = function asyncMapSettled(iterable, mapFn, thisArg = iterable) {
-  return new Promise((resolve, reject) => {
-    const onError = e => {
-      if (result !== undefined) {
-        error = e
-        result = undefined
-      }
-      if (--n === 0) {
-        reject(error)
-      }
-    }
-    const onValue = (i, value) => {
-      const hasError = result === undefined
-      if (!hasError) {
-        result[i] = value
-      }
-      if (--n === 0) {
-        if (hasError) {
-          reject(error)
-        } else {
-          resolve(result)
-        }
-      }
-    }
-
-    let n = 0
-    for (const item of iterable) {
-      const i = n++
-      wrapCall(mapFn, item, thisArg).then(value => onValue(i, value), onError)
-    }
-
-    if (n === 0) {
-      return resolve([])
-    }
-
-    let error
-    let result = new Array(n)
-  })
-}

@xen-orchestra/async-map/index.spec.js

@@ -1,73 +0,0 @@
-'use strict'
-
-/* eslint-env jest */
-
-const { asyncMapSettled } = require('./')
-
-const noop = Function.prototype
-
-describe('asyncMapSettled', () => {
-  it('works', async () => {
-    const values = [Math.random(), Math.random()]
-    const spy = jest.fn(async v => v * 2)
-    const iterable = new Set(values)
-
-    // returns an array containing the result of each calls
-    expect(await asyncMapSettled(iterable, spy)).toEqual(values.map(value => value * 2))
-
-    for (let i = 0, n = values.length; i < n; ++i) {
-      // each call receive the current item as sole argument
-      expect(spy.mock.calls[i]).toEqual([values[i]])
-
-      // each call as this bind to the iterable
-      expect(spy.mock.instances[i]).toBe(iterable)
-    }
-  })
-
-  it('can use a specified thisArg', () => {
-    const thisArg = {}
-    const spy = jest.fn()
-    asyncMapSettled(['foo'], spy, thisArg)
-    expect(spy.mock.instances[0]).toBe(thisArg)
-  })
-
-  it('rejects only when all calls as resolved', async () => {
-    const defers = []
-    const promise = asyncMapSettled([1, 2], () => {
-      let resolve, reject
-      // eslint-disable-next-line promise/param-names
-      const promise = new Promise((_resolve, _reject) => {
-        resolve = _resolve
-        reject = _reject
-      })
-      defers.push({ promise, resolve, reject })
-      return promise
-    })
-
-    let hasSettled = false
-    promise.catch(noop).then(() => {
-      hasSettled = true
-    })
-
-    const error = new Error()
-    defers[0].reject(error)
-
-    // wait for all microtasks to settle
-    await new Promise(resolve => setImmediate(resolve))
-
-    expect(hasSettled).toBe(false)
-
-    defers[1].resolve()
-
-    // wait for all microtasks to settle
-    await new Promise(resolve => setImmediate(resolve))
-
-    expect(hasSettled).toBe(true)
-    await expect(promise).rejects.toBe(error)
-  })
-
-  it('issues when latest promise rejects', async () => {
-    const error = new Error()
-    await expect(asyncMapSettled([1], () => Promise.reject(error))).rejects.toBe(error)
-  })
-})

@xen-orchestra/async-map/package.json

@@ -1,17 +1,9 @@
 {
-  "private": false,
   "name": "@xen-orchestra/async-map",
-  "version": "0.1.2",
+  "version": "0.0.0",
   "license": "ISC",
-  "description": "Promise.all + map for all iterables",
-  "keywords": [
-    "array",
-    "async",
-    "iterable",
-    "map",
-    "settled",
-    "typescript"
-  ],
+  "description": "",
+  "keywords": [],
   "homepage": "https://github.com/vatesfr/xen-orchestra/tree/master/@xen-orchestra/async-map",
   "bugs": "https://github.com/vatesfr/xen-orchestra/issues",
   "repository": {
@@ -20,17 +12,41 @@
     "url": "https://github.com/vatesfr/xen-orchestra.git"
   },
   "author": {
-    "name": "Vates SAS",
-    "url": "https://vates.fr"
+    "name": "Julien Fontanet",
+    "email": "julien.fontanet@isonoe.net"
   },
   "preferGlobal": false,
+  "main": "dist/",
+  "bin": {},
+  "files": [
+    "dist/"
+  ],
+  "browserslist": [
+    ">2%"
+  ],
   "engines": {
     "node": ">=6"
   },
   "dependencies": {
     "lodash": "^4.17.4"
   },
+  "devDependencies": {
+    "@babel/cli": "^7.0.0",
+    "@babel/core": "^7.0.0",
+    "@babel/preset-env": "^7.0.0",
+    "@babel/preset-flow": "^7.0.0",
+    "babel-plugin-lodash": "^3.3.2",
+    "cross-env": "^5.1.3",
+    "rimraf": "^2.6.2"
+  },
   "scripts": {
+    "build": "cross-env NODE_ENV=production babel --source-maps --out-dir=dist/ src/",
+    "clean": "rimraf dist/",
+    "dev": "cross-env NODE_ENV=development babel --watch --source-maps --out-dir=dist/ src/",
+    "prebuild": "yarn run clean",
+    "predev": "yarn run prebuild",
+    "prepare": "yarn run build",
+    "prepublishOnly": "yarn run build",
     "postversion": "npm publish"
   }
 }

@xen-orchestra/async-map/src/index.js

@@ -1,5 +1,3 @@
-'use strict'
-
 // type MaybePromise<T> = Promise<T> | T
 //
 // declare export function asyncMap<T1, T2>(
@@ -11,18 +9,14 @@
 //   (V1, K) => MaybePromise<V2>
 // ): Promise<V2[]>
 
-const map = require('lodash/map')
+import map from 'lodash/map'
 
-/**
- * Similar to map() + Promise.all() but wait for all promises to settle before
- * rejecting (with the first error)
- *
- * @deprecated Don't support iterables, please use new implementations
- */
-module.exports = function asyncMapLegacy(collection, iteratee) {
+// Similar to map() + Promise.all() but wait for all promises to
+// settle before rejecting (with the first error)
+const asyncMap = (collection, iteratee) => {
   let then
   if (collection != null && typeof (then = collection.then) === 'function') {
-    return then.call(collection, collection => asyncMapLegacy(collection, iteratee))
+    return then.call(collection, collection => asyncMap(collection, iteratee))
   }
 
   let errorContainer
@@ -45,3 +39,5 @@ module.exports = function asyncMapLegacy(collection, iteratee) {
     return values
   })
 }
+
+export { asyncMap as default }

@xen-orchestra/audit-core/.npmignore

@@ -1 +0,0 @@
-../../scripts/npmignore

@xen-orchestra/audit-core/README.md

@@ -1,28 +0,0 @@
-<!-- DO NOT EDIT MANUALLY, THIS FILE HAS BEEN GENERATED -->
-
-# @xen-orchestra/audit-core
-
-[![Package Version](https://badgen.net/npm/v/@xen-orchestra/audit-core)](https://npmjs.org/package/@xen-orchestra/audit-core) ![License](https://badgen.net/npm/license/@xen-orchestra/audit-core) [![PackagePhobia](https://badgen.net/bundlephobia/minzip/@xen-orchestra/audit-core)](https://bundlephobia.com/result?p=@xen-orchestra/audit-core) [![Node compatibility](https://badgen.net/npm/node/@xen-orchestra/audit-core)](https://npmjs.org/package/@xen-orchestra/audit-core)
-
-## Install
-
-Installation of the [npm package](https://npmjs.org/package/@xen-orchestra/audit-core):
-
-```
-> npm install --save @xen-orchestra/audit-core
-```
-
-## Contributions
-
-Contributions are _very_ welcomed, either on the documentation or on
-the code.
-
-You may:
-
-- report any [issue](https://github.com/vatesfr/xen-orchestra/issues)
-  you've encountered;
-- fork and create a pull request.
-
-## License
-
-[AGPL-3.0-or-later](https://spdx.org/licenses/AGPL-3.0-or-later) © [Vates SAS](https://vates.fr)

@xen-orchestra/audit-core/docs/specification.ts

@@ -1,26 +0,0 @@
-class Storage {
-  acquire: () => Promise<() => undefined>
-  del: (id: string) => Promise<void>
-  get: (id: string) => Promise<Record | void>
-  getLastId: () => Promise<string | void>
-  put: (record: Record) => Promise<void>
-  setLastId: (id: string) => Promise<void>
-}
-
-interface Record {
-  data: object
-  event: string
-  id: string
-  previousId: string
-  subject: object
-  time: number
-}
-
-export class AuditCore {
-  constructor(storage: Storage) {}
-  public add(subject: any, event: string, data: any): Promise<Record> {}
-  public checkIntegrity(oldest: string, newest: string): Promise<number> {}
-  public getFrom(newest?: string): AsyncIterator {}
-  public deleteFrom(newest: string): Promise<void> {}
-  public deleteRangeAndRewrite(newest: string, oldest: string): Promise<void> {}
-}

@xen-orchestra/audit-core/index.js

@@ -1,200 +0,0 @@
-'use strict'
-
-const assert = require('assert')
-const hash = require('object-hash')
-const { createLogger } = require('@xen-orchestra/log')
-const { decorateClass } = require('@vates/decorate-with')
-const { defer } = require('golike-defer')
-
-const log = createLogger('xo:audit-core')
-
-exports.Storage = class Storage {
-  constructor() {
-    this._lock = Promise.resolve()
-  }
-
-  async acquireLock() {
-    const lock = this._lock
-    let releaseLock
-    this._lock = new Promise(resolve => {
-      releaseLock = resolve
-    })
-    await lock
-    return releaseLock
-  }
-}
-
-// Format: $<algorithm>$<salt>$<encrypted>
-//
-// http://man7.org/linux/man-pages/man3/crypt.3.html#NOTES
-const ID_TO_ALGORITHM = {
-  5: 'sha256',
-}
-
-class AlteredRecordError extends Error {
-  constructor(id, nValid, record) {
-    super('altered record')
-
-    this.id = id
-    this.nValid = nValid
-    this.record = record
-  }
-}
-exports.AlteredRecordError = AlteredRecordError
-
-class MissingRecordError extends Error {
-  constructor(id, nValid) {
-    super('missing record')
-
-    this.id = id
-    this.nValid = nValid
-  }
-}
-exports.MissingRecordError = MissingRecordError
-
-const NULL_ID = 'nullId'
-exports.NULL_ID = NULL_ID
-
-const HASH_ALGORITHM_ID = '5'
-const createHash = (data, algorithmId = HASH_ALGORITHM_ID) =>
-  `$${algorithmId}$$${hash(data, {
-    algorithm: ID_TO_ALGORITHM[algorithmId],
-    excludeKeys: key => key === 'id',
-  })}`
-
-class AuditCore {
-  constructor(storage) {
-    assert.notStrictEqual(storage, undefined)
-    this._storage = storage
-  }
-
-  async add($defer, subject, event, data) {
-    const time = Date.now()
-    $defer(await this._storage.acquireLock())
-    return this._addUnsafe({
-      data,
-      event,
-      subject,
-      time,
-    })
-  }
-
-  async _addUnsafe({ data, event, subject, time }) {
-    const storage = this._storage
-
-    // delete "undefined" properties and normalize data with JSON.stringify
-    const record = JSON.parse(
-      JSON.stringify({
-        data,
-        event,
-        previousId: (await storage.getLastId()) ?? NULL_ID,
-        subject,
-        time,
-      })
-    )
-    record.id = createHash(record)
-    await storage.put(record)
-    await storage.setLastId(record.id)
-    return record
-  }
-
-  async checkIntegrity(oldest, newest) {
-    const storage = this._storage
-
-    // handle separated chains case
-    if (newest !== (await storage.getLastId())) {
-      let isNewestAccessible = false
-      for await (const { id } of this.getFrom()) {
-        if (id === newest) {
-          isNewestAccessible = true
-          break
-        }
-      }
-      if (!isNewestAccessible) {
-        throw new MissingRecordError(newest, 0)
-      }
-    }
-
-    let nValid = 0
-    while (newest !== oldest) {
-      const record = await storage.get(newest)
-      if (record === undefined) {
-        throw new MissingRecordError(newest, nValid)
-      }
-      if (newest !== createHash(record, newest.slice(1, newest.indexOf('$', 1)))) {
-        throw new AlteredRecordError(newest, nValid, record)
-      }
-      newest = record.previousId
-      nValid++
-    }
-    return nValid
-  }
-
-  async *getFrom(newest) {
-    const storage = this._storage
-
-    let id = newest ?? (await storage.getLastId())
-    if (id === undefined) {
-      return
-    }
-
-    let record
-    while ((record = await storage.get(id)) !== undefined) {
-      yield record
-      id = record.previousId
-    }
-  }
-
-  async deleteFrom(newest) {
-    assert.notStrictEqual(newest, undefined)
-    for await (const { id } of this.getFrom(newest)) {
-      await this._storage.del(id)
-    }
-  }
-
-  async deleteRangeAndRewrite($defer, newest, oldest) {
-    assert.notStrictEqual(newest, undefined)
-    assert.notStrictEqual(oldest, undefined)
-
-    const storage = this._storage
-    $defer(await storage.acquireLock())
-
-    assert.notStrictEqual(await storage.get(newest), undefined)
-    const oldestRecord = await storage.get(oldest)
-    assert.notStrictEqual(oldestRecord, undefined)
-
-    const lastId = await storage.getLastId()
-    const recentRecords = []
-    for await (const record of this.getFrom(lastId)) {
-      if (record.id === newest) {
-        break
-      }
-
-      recentRecords.push(record)
-    }
-
-    for await (const record of this.getFrom(newest)) {
-      await storage.del(record.id)
-      if (record.id === oldest) {
-        break
-      }
-    }
-
-    await storage.setLastId(oldestRecord.previousId)
-
-    for (const record of recentRecords) {
-      try {
-        await this._addUnsafe(record)
-        await storage.del(record.id)
-      } catch (error) {
-        log.error(error)
-      }
-    }
-  }
-}
-exports.AuditCore = AuditCore
-
-decorateClass(AuditCore, {
-  add: defer,
-  deleteRangeAndRewrite: defer,
-})

@xen-orchestra/audit-core/index.spec.js

@@ -1,120 +0,0 @@
-'use strict'
-
-const assert = require('assert/strict')
-const { afterEach, describe, it } = require('tap').mocha
-
-const { AlteredRecordError, AuditCore, MissingRecordError, NULL_ID, Storage } = require('.')
-
-const asyncIteratorToArray = async asyncIterator => {
-  const array = []
-  for await (const entry of asyncIterator) {
-    array.push(entry)
-  }
-  return array
-}
-
-class DB extends Storage {
-  constructor() {
-    super()
-
-    this._db = new Map()
-    this._lastId = undefined
-  }
-
-  async put(record) {
-    this._db.set(record.id, record)
-  }
-
-  async setLastId(id) {
-    this._lastId = id
-  }
-
-  async getLastId() {
-    return this._lastId
-  }
-
-  async del(id) {
-    this._db.delete(id)
-  }
-
-  async get(id) {
-    return this._db.get(id)
-  }
-
-  _clear() {
-    return this._db.clear()
-  }
-}
-
-const DATA = [
-  [
-    {
-      name: 'subject0',
-    },
-    'event0',
-    {},
-  ],
-  [
-    {
-      name: 'subject1',
-    },
-    'event1',
-    {},
-  ],
-  [
-    {
-      name: 'subject2',
-    },
-    'event2',
-    {},
-  ],
-]
-
-const db = new DB()
-const auditCore = new AuditCore(db)
-const storeAuditRecords = async () => {
-  await Promise.all(DATA.map(data => auditCore.add(...data)))
-  const records = await asyncIteratorToArray(auditCore.getFrom())
-  assert.equal(records.length, DATA.length)
-  return records
-}
-
-describe('auditCore', () => {
-  afterEach(() => db._clear())
-
-  it('detects that a record is missing', async () => {
-    const [newestRecord, deletedRecord] = await storeAuditRecords()
-
-    const nValidRecords = await auditCore.checkIntegrity(NULL_ID, newestRecord.id)
-    assert.equal(nValidRecords, DATA.length)
-
-    await db.del(deletedRecord.id)
-    await assert.rejects(
-      auditCore.checkIntegrity(NULL_ID, newestRecord.id),
-      new MissingRecordError(deletedRecord.id, 1)
-    )
-  })
-
-  it('detects that a record has been altered', async () => {
-    const [newestRecord, alteredRecord] = await storeAuditRecords()
-
-    alteredRecord.event = ''
-    await db.put(alteredRecord)
-
-    await assert.rejects(
-      auditCore.checkIntegrity(NULL_ID, newestRecord.id),
-      new AlteredRecordError(alteredRecord.id, 1, alteredRecord)
-    )
-  })
-
-  it('confirms interval integrity after deletion of records outside of the interval', async () => {
-    const [thirdRecord, secondRecord, firstRecord] = await storeAuditRecords()
-
-    await auditCore.deleteFrom(secondRecord.id)
-
-    assert.equal(await db.get(firstRecord.id), undefined)
-    assert.equal(await db.get(secondRecord.id), undefined)
-
-    await auditCore.checkIntegrity(secondRecord.id, thirdRecord.id)
-  })
-})

@xen-orchestra/audit-core/package.json

@@ -1,33 +0,0 @@
-{
-  "name": "@xen-orchestra/audit-core",
-  "homepage": "https://github.com/vatesfr/xen-orchestra/tree/master/@xen-orchestra/audit-core",
-  "bugs": "https://github.com/vatesfr/xen-orchestra/issues",
-  "repository": {
-    "directory": "@xen-orchestra/audit-core",
-    "type": "git",
-    "url": "https://github.com/vatesfr/xen-orchestra.git"
-  },
-  "version": "0.2.0",
-  "engines": {
-    "node": ">=14"
-  },
-  "scripts": {
-    "postversion": "npm publish --access public",
-    "test": "tap --lines 67 --functions 92 --branches 52 --statements 67"
-  },
-  "dependencies": {
-    "@vates/decorate-with": "^2.0.0",
-    "@xen-orchestra/log": "^0.3.0",
-    "golike-defer": "^0.5.1",
-    "object-hash": "^2.0.1"
-  },
-  "private": false,
-  "license": "AGPL-3.0-or-later",
-  "author": {
-    "name": "Vates SAS",
-    "url": "https://vates.fr"
-  },
-  "devDependencies": {
-    "tap": "^16.0.1"
-  }
-}

@xen-orchestra/babel-config/.npmignore

@@ -1 +0,0 @@
-../../scripts/npmignore

@xen-orchestra/babel-config/README.md

@@ -1,18 +0,0 @@
-<!-- DO NOT EDIT MANUALLY, THIS FILE HAS BEEN GENERATED -->
-
-# @xen-orchestra/babel-config
-
-## Contributions
-
-Contributions are _very_ welcomed, either on the documentation or on
-the code.
-
-You may:
-
-- report any [issue](https://github.com/vatesfr/xen-orchestra/issues)
-  you've encountered;
-- fork and create a pull request.
-
-## License
-
-[AGPL-3.0-or-later](https://spdx.org/licenses/AGPL-3.0-or-later) © [Vates SAS](https://vates.fr)

@xen-orchestra/babel-config/index.js

@@ -14,39 +14,59 @@ const configs = {
   '@babel/plugin-proposal-pipeline-operator': {
     proposal: 'minimal',
   },
-  '@babel/preset-env': {
-    debug: !__TEST__,
+  '@babel/preset-env'(pkg) {
+    return {
+      debug: !__TEST__,
 
-    // disabled until https://github.com/babel/babel/issues/8323 is resolved
-    // loose: true,
+      // disabled until https://github.com/babel/babel/issues/8323 is resolved
+      // loose: true,
 
-    shippedProposals: true,
+      shippedProposals: true,
+      targets: (() => {
+        let node = (pkg.engines || {}).node
+        if (node !== undefined) {
+          const trimChars = '^=>~'
+          while (trimChars.includes(node[0])) {
+            node = node.slice(1)
+          }
+        }
+        return { browsers: pkg.browserslist, node }
+      })(),
+      useBuiltIns: '@babel/polyfill' in (pkg.dependencies || {}) && 'usage',
+    }
   },
 }
 
 const getConfig = (key, ...args) => {
   const config = configs[key]
-  return config === undefined ? {} : typeof config === 'function' ? config(...args) : config
+  return config === undefined
+    ? {}
+    : typeof config === 'function'
+    ? config(...args)
+    : config
 }
 
 // some plugins must be used in a specific order
-const pluginsOrder = ['@babel/plugin-proposal-decorators', '@babel/plugin-proposal-class-properties']
+const pluginsOrder = [
+  '@babel/plugin-proposal-decorators',
+  '@babel/plugin-proposal-class-properties',
+]
 
-module.exports = function (pkg, configs = {}) {
-  const plugins = {}
-  const presets = {}
+module.exports = function(pkg, plugins, presets) {
+  plugins === undefined && (plugins = {})
+  presets === undefined && (presets = {})
 
   Object.keys(pkg.devDependencies || {}).forEach(name => {
     if (!(name in presets) && PLUGINS_RE.test(name)) {
-      plugins[name] = { ...getConfig(name, pkg), ...configs[name] }
+      plugins[name] = getConfig(name, pkg)
     } else if (!(name in presets) && PRESETS_RE.test(name)) {
-      presets[name] = { ...getConfig(name, pkg), ...configs[name] }
+      presets[name] = getConfig(name, pkg)
     }
   })
 
   return {
     comments: !__PROD__,
-    ignore: __PROD__ ? [/\btests?\//, /\.spec\.js$/] : undefined,
+    ignore: __TEST__ ? undefined : [/\.spec\.js$/],
     plugins: Object.keys(plugins)
       .map(plugin => [plugin, plugins[plugin]])
       .sort(([a], [b]) => {
@@ -55,15 +75,5 @@ module.exports = function (pkg, configs = {}) {
         return oA !== -1 && oB !== -1 ? oA - oB : a < b ? -1 : 1
       }),
     presets: Object.keys(presets).map(preset => [preset, presets[preset]]),
-    targets: (() => {
-      let node = (pkg.engines || {}).node
-      if (node !== undefined) {
-        const trimChars = '^=>~'
-        while (trimChars.includes(node[0])) {
-          node = node.slice(1)
-        }
-      }
-      return { browsers: pkg.browserslist, node }
-    })(),
   }
 }

@xen-orchestra/babel-config/package.json

@@ -8,13 +8,5 @@
     "directory": "@xen-orchestra/babel-config",
     "type": "git",
     "url": "https://github.com/vatesfr/xen-orchestra.git"
-  },
-  "engines": {
-    "node": ">=8.3"
-  },
-  "license": "AGPL-3.0-or-later",
-  "author": {
-    "name": "Vates SAS",
-    "url": "https://vates.fr"
   }
 }

@xen-orchestra/backups-cli/.USAGE.md

@@ -1,17 +0,0 @@
-```
-> xo-backups --help
-Usage:
-
-    xo-backups clean-vms [--merge] [--remove] xo-vm-backups/*
-
-      Detects and repair issues with VM backups.
-
-      Options:
-        -m, --merge     Merge (or continue merging) VHD files that are unused
-        -r, --remove    Remove unused, incomplete, orphan, or corrupted files
-
-
-    xo-backups create-symlink-index xo-vm-backups <field path>
-
-    xo-backups info xo-vm-backups/*
-```