@automattic/vip 4.1.6 → 4.1.8

package/node_modules/check-disk-space/dist/check-disk-space.cjs

@@ -1,210 +0,0 @@
-'use strict';
-
-Object.defineProperty(exports, '__esModule', { value: true });
-
-var node_child_process = require('node:child_process');
-var promises = require('node:fs/promises');
-var node_os = require('node:os');
-var node_path = require('node:path');
-var node_process = require('node:process');
-var node_util = require('node:util');
-
-class InvalidPathError extends Error {
-    constructor(message) {
-        super(message);
-        this.name = 'InvalidPathError';
-        // Set the prototype explicitly.
-        Object.setPrototypeOf(this, InvalidPathError.prototype);
-    }
-}
-
-class NoMatchError extends Error {
-    constructor(message) {
-        super(message);
-        this.name = 'NoMatchError';
-        // Set the prototype explicitly.
-        Object.setPrototypeOf(this, NoMatchError.prototype);
-    }
-}
-
-/**
- * Tells if directory exists
- *
- * @param directoryPath - The file/folder path
- * @param dependencies - Dependencies container
- */
-async function isDirectoryExisting(directoryPath, dependencies) {
-    try {
-        await dependencies.fsAccess(directoryPath);
-        return Promise.resolve(true);
-    }
-    catch (error) {
-        return Promise.resolve(false);
-    }
-}
-
-/**
- * Get the first existing parent path
- *
- * @param directoryPath - The file/folder path from where we want to know disk space
- * @param dependencies - Dependencies container
- */
-async function getFirstExistingParentPath(directoryPath, dependencies) {
-    let parentDirectoryPath = directoryPath;
-    let parentDirectoryFound = await isDirectoryExisting(parentDirectoryPath, dependencies);
-    while (!parentDirectoryFound) {
-        parentDirectoryPath = dependencies.pathNormalize(parentDirectoryPath + '/..');
-        parentDirectoryFound = await isDirectoryExisting(parentDirectoryPath, dependencies);
-    }
-    return parentDirectoryPath;
-}
-
-/**
- * Tell if PowerShell 3 is available based on Windows version
- *
- * Note: 6.* is Windows 7
- * Note: PowerShell 3 is natively available since Windows 8
- *
- * @param dependencies - Dependencies Injection Container
- */
-async function hasPowerShell3(dependencies) {
-    const major = parseInt(dependencies.release.split('.')[0], 10);
-    if (major <= 6) {
-        return false;
-    }
-    try {
-        await dependencies.cpExecFile('where', ['powershell'], { windowsHide: true });
-        return true;
-    }
-    catch (error) {
-        return false;
-    }
-}
-
-/**
- * Check disk space
- *
- * @param directoryPath - The file/folder path from where we want to know disk space
- * @param dependencies - Dependencies container
- */
-function checkDiskSpace(directoryPath, dependencies = {
-    platform: node_process.platform,
-    release: node_os.release(),
-    fsAccess: promises.access,
-    pathNormalize: node_path.normalize,
-    pathSep: node_path.sep,
-    cpExecFile: node_util.promisify(node_child_process.execFile),
-}) {
-    // Note: This function contains other functions in order
-    //       to wrap them in a common context and make unit tests easier
-    /**
-     * Maps command output to a normalized object {diskPath, free, size}
-     *
-     * @param stdout - The command output
-     * @param filter - To filter drives (only used for win32)
-     * @param mapping - Map between column index and normalized column name
-     * @param coefficient - The size coefficient to get bytes instead of kB
-     */
-    function mapOutput(stdout, filter, mapping, coefficient) {
-        const parsed = stdout
-            .split('\n') // Split lines
-            .map(line => line.trim()) // Trim all lines
-            .filter(line => line.length !== 0) // Remove empty lines
-            .slice(1) // Remove header
-            .map(line => line.split(/\s+(?=[\d/])/)); // Split on spaces to get columns
-        const filtered = parsed.filter(filter);
-        if (filtered.length === 0) {
-            throw new NoMatchError();
-        }
-        const diskData = filtered[0];
-        return {
-            diskPath: diskData[mapping.diskPath],
-            free: parseInt(diskData[mapping.free], 10) * coefficient,
-            size: parseInt(diskData[mapping.size], 10) * coefficient,
-        };
-    }
-    /**
-     * Run the command and do common things between win32 and unix
-     *
-     * @param cmd - The command to execute
-     * @param filter - To filter drives (only used for win32)
-     * @param mapping - Map between column index and normalized column name
-     * @param coefficient - The size coefficient to get bytes instead of kB
-     */
-    async function check(cmd, filter, mapping, coefficient = 1) {
-        const [file, ...args] = cmd;
-        /* istanbul ignore if */
-        if (file === undefined) {
-            return Promise.reject(new Error('cmd must contain at least one item'));
-        }
-        try {
-            const { stdout } = await dependencies.cpExecFile(file, args, { windowsHide: true });
-            return mapOutput(stdout, filter, mapping, coefficient);
-        }
-        catch (error) {
-            return Promise.reject(error);
-        }
-    }
-    /**
-     * Build the check call for win32
-     *
-     * @param directoryPath - The file/folder path from where we want to know disk space
-     */
-    async function checkWin32(directoryPath) {
-        if (directoryPath.charAt(1) !== ':') {
-            return Promise.reject(new InvalidPathError(`The following path is invalid (should be X:\\...): ${directoryPath}`));
-        }
-        const powershellCmd = [
-            'powershell',
-            'Get-CimInstance -ClassName Win32_LogicalDisk | Select-Object Caption, FreeSpace, Size',
-        ];
-        const wmicCmd = [
-            'wmic',
-            'logicaldisk',
-            'get',
-            'size,freespace,caption',
-        ];
-        const cmd = await hasPowerShell3(dependencies) ? powershellCmd : wmicCmd;
-        return check(cmd, driveData => {
-            // Only get the drive which match the path
-            const driveLetter = driveData[0];
-            return directoryPath.toUpperCase().startsWith(driveLetter.toUpperCase());
-        }, {
-            diskPath: 0,
-            free: 1,
-            size: 2,
-        });
-    }
-    /**
-     * Build the check call for unix
-     *
-     * @param directoryPath - The file/folder path from where we want to know disk space
-     */
-    async function checkUnix(directoryPath) {
-        if (!dependencies.pathNormalize(directoryPath).startsWith(dependencies.pathSep)) {
-            return Promise.reject(new InvalidPathError(`The following path is invalid (should start by ${dependencies.pathSep}): ${directoryPath}`));
-        }
-        const pathToCheck = await getFirstExistingParentPath(directoryPath, dependencies);
-        return check([
-            'df',
-            '-Pk',
-            '--',
-            pathToCheck,
-        ], () => true, // We should only get one line, so we did not need to filter
-        {
-            diskPath: 5,
-            free: 3,
-            size: 1,
-        }, 1024);
-    }
-    // Call the right check depending on the OS
-    if (dependencies.platform === 'win32') {
-        return checkWin32(directoryPath);
-    }
-    return checkUnix(directoryPath);
-}
-
-exports.InvalidPathError = InvalidPathError;
-exports.NoMatchError = NoMatchError;
-exports.default = checkDiskSpace;
-exports.getFirstExistingParentPath = getFirstExistingParentPath;

package/node_modules/check-disk-space/dist/check-disk-space.d.ts

@@ -1,53 +0,0 @@
-import { access } from 'node:fs/promises';
-import { normalize, sep } from 'node:path';
-
-declare class InvalidPathError extends Error {
-    name: string;
-    constructor(message?: string);
-}
-
-declare class NoMatchError extends Error {
-    name: string;
-    constructor(message?: string);
-}
-
-type Dependencies = {
-    platform: NodeJS.Platform;
-    release: string;
-    fsAccess: typeof access;
-    pathNormalize: typeof normalize;
-    pathSep: typeof sep;
-    cpExecFile: (file: string, args: ReadonlyArray<string> | undefined | null, options: {
-        windowsHide: true;
-    }) => Promise<{
-        stdout: string;
-        stderr: string;
-    }>;
-};
-
-/**
- * Get the first existing parent path
- *
- * @param directoryPath - The file/folder path from where we want to know disk space
- * @param dependencies - Dependencies container
- */
-declare function getFirstExistingParentPath(directoryPath: string, dependencies: Dependencies): Promise<string>;
-
-/**
- * `free` and `size` are in bytes
- */
-type DiskSpace = {
-    diskPath: string;
-    free: number;
-    size: number;
-};
-
-/**
- * Check disk space
- *
- * @param directoryPath - The file/folder path from where we want to know disk space
- * @param dependencies - Dependencies container
- */
-declare function checkDiskSpace(directoryPath: string, dependencies?: Dependencies): Promise<DiskSpace>;
-
-export { Dependencies, DiskSpace, InvalidPathError, NoMatchError, checkDiskSpace as default, getFirstExistingParentPath };

package/node_modules/fetch-retry/.eslintignore

@@ -1 +0,0 @@
-*.d.ts

package/node_modules/fetch-retry/.eslintrc.yml

@@ -1,20 +0,0 @@
-env:
-  browser: true
-  commonjs: true
-  es6: false
-extends: 'eslint:recommended'
-parserOptions:
-  ecmaVersion: 5
-rules:
-  indent:
-    - warn
-    - 2
-  linebreak-style:
-    - warn
-    - unix
-  quotes:
-    - warn
-    - single
-  semi:
-    - warn
-    - always

package/node_modules/fetch-retry/.github/workflows/node.js.yml

@@ -1,32 +0,0 @@
-# This workflow will do a clean installation of node dependencies, cache/restore them, build the source code and run tests across different versions of node
-# For more information see: https://docs.github.com/en/actions/automating-builds-and-tests/building-and-testing-nodejs
-
-name: Node.js CI
-
-on:
-  push:
-    branches: [ "master" ]
-  pull_request:
-    branches: [ "master" ]
-
-jobs:
-  build:
-
-    runs-on: ubuntu-latest
-
-    strategy:
-      matrix:
-        node-version: [14.x, 16.x, 18.x]
-        # See supported Node.js release schedule at https://nodejs.org/en/about/releases/
-
-    steps:
-    - uses: actions/checkout@v3
-    - name: Use Node.js ${{ matrix.node-version }}
-      uses: actions/setup-node@v3
-      with:
-        node-version: ${{ matrix.node-version }}
-        cache: 'npm'
-    - run: npm install # dev-dependencies are needed in order to run tests and for Rollup
-    - run: npm run build --if-present
-    - run: npm test
-    - run: npm ci

package/node_modules/fetch-retry/.husky/pre-commit

@@ -1,6 +0,0 @@
-#!/bin/sh
-. "$(dirname "$0")/_/husky.sh"
-
-npm run build
-npm test
-git add -A .

package/node_modules/fetch-retry/.nycrc.json

@@ -1,24 +0,0 @@
-{
-  "include": [
-    "**/*.js"
-  ],
-  "exclude": [
-    "coverage/**",
-    "test/**",
-    "test{,-*}.js",
-    "**/*.test.js",
-    "**/__tests__/**",
-    "**/node_modules/**",
-    "**/*.spec.js"
-  ],
-  "reporter": [
-    "lcov",
-    "text"
-  ],
-  "check-coverage": true,
-  "per-file": false,
-  "statements": 100,
-  "branches": 100,
-  "functions": 100,
-  "lines": 100
-}

package/node_modules/fetch-retry/.travis.yml

@@ -1,3 +0,0 @@
-language: node_js
-node_js:
-  - "10"

package/node_modules/fetch-retry/LICENSE

@@ -1,21 +0,0 @@
-The MIT License (MIT)
-
-Copyright (c) 2016 Jon K. Bernhardsen
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.

package/node_modules/fetch-retry/README.md

@@ -1,128 +0,0 @@
-# fetch-retry
-
-Adds retry functionality to the [Fetch](https://fetch.spec.whatwg.org/) API.
-
-It wraps any `fetch` API package (eg: [isomorphic-fetch](https://github.com/matthew-andrews/isomorphic-fetch), [cross-fetch](https://github.com/lquixada/cross-fetch), [isomorphic-unfetch](https://github.com/developit/unfetch), or [Node.js native's fetch implementation](https://nodejs.org/dist/latest-v18.x/docs/api/globals.html#fetch)) and retries requests that fail due to network issues. It can also be configured to retry requests on specific HTTP status codes.
-
-[![Node.js CI](https://github.com/jonbern/fetch-retry/actions/workflows/node.js.yml/badge.svg)](https://github.com/jonbern/fetch-retry/actions/workflows/node.js.yml)
-
-## npm package
-
-```javascript
-npm install fetch-retry --save
-```
-
-## Example
-`fetch-retry` is used the same way as `fetch`, but also accepts `retries`, `retryDelay`, and `retryOn` on the `options` object.
-
-These properties are optional, and unless different defaults have been specified when requiring `fetch-retry`, these will default to 3 retries, with a 1000ms retry delay, and to only retry on network errors.
-
-```javascript
-const originalFetch = require('isomorphic-fetch');
-const fetch = require('fetch-retry')(originalFetch);
-
-// fetch-retry can also wrap Node.js's native fetch API implementation:
-const fetch = require('fetch-retry')(global.fetch);
-```
-
-```javascript
-fetch(url, {
-    retries: 3,
-    retryDelay: 1000
-  })
-  .then(function(response) {
-    return response.json();
-  })
-  .then(function(json) {
-    // do something with the result
-    console.log(json);
-  });
-```
-
-or passing your own defaults:
-
-```javascript
-const originalFetch = require('isomorphic-fetch');
-const fetch = require('fetch-retry')(originalFetch, {
-    retries: 5,
-    retryDelay: 800
-  });
-```
-
-> `fetch-retry` uses promises and requires you to polyfill the Promise API in order to support Internet Explorer.
-
-
-## Example: Exponential backoff
-The default behavior of `fetch-retry` is to wait a fixed amount of time between attempts, but it is also possible to customize this by passing a function as the `retryDelay` option. The function is supplied three arguments: `attempt` (starting at 0), `error` (in case of a network error), and `response`. It must return a number indicating the delay.
-
-```javascript
-fetch(url, {
-    retryDelay: function(attempt, error, response) {
-      return Math.pow(2, attempt) * 1000; // 1000, 2000, 4000
-    }
-  }).then(function(response) {
-    return response.json();
-  }).then(function(json) {
-    // do something with the result
-    console.log(json);
-  });
-```
-
-## Example: Retry on 503 (Service Unavailable)
-The default behavior of `fetch-retry` is to only retry requests on network related issues, but it is also possible to configure it to retry on specific HTTP status codes. This is done by using the `retryOn` property, which expects an array of HTTP status codes.
-
-```javascript
-fetch(url, {
-    retryOn: [503]
-  })
-  .then(function(response) {
-    return response.json();
-  })
-  .then(function(json) {
-    // do something with the result
-    console.log(json);
-  });
-```
-
-## Example: Retry custom behavior
-The `retryOn` option may also be specified as a function, in which case it will be supplied three arguments: `attempt` (starting at 0), `error` (in case of a network error), and `response`. Return a truthy value from this function in order to trigger a retry, any falsy value will result in the call to fetch either resolving (in case the last attempt resulted in a response), or rejecting (in case the last attempt resulted in an error).
-
-```javascript
-fetch(url, {
-    retryOn: function(attempt, error, response) {
-      // retry on any network error, or 4xx or 5xx status codes
-      if (error !== null || response.status >= 400) {
-        console.log(`retrying, attempt number ${attempt + 1}`);
-        return true;
-      }
-    })
-    .then(function(response) {
-      return response.json();
-    }).then(function(json) {
-      // do something with the result
-      console.log(json);
-    });
-```
-
-## Example: Retry custom behavior with async
-The `retryOn` option may also be used with async and await for calling asyncronous functions:
-
-```javascript
-fetch(url, {
-    retryOn: async function(attempt, error, response) {
-      if (attempt > 3) return false;
-
-      if (error !== null) {
-        var json = await response.json();
-        if (json.property !== undefined) {
-          return true;
-        }
-      }
-    })
-    .then(function(response) {
-      return response.json();
-    }).then(function(json) {
-      // do something with the result
-      console.log(json);
-    });
-```

package/node_modules/fetch-retry/dist/fetch-retry.umd.js

@@ -1,151 +0,0 @@
-(function (global, factory) {
-  typeof exports === 'object' && typeof module !== 'undefined' ? module.exports = factory() :
-  typeof define === 'function' && define.amd ? define(factory) :
-  (global = typeof globalThis !== 'undefined' ? globalThis : global || self, global.fetchRetry = factory());
-})(this, (function () { 'use strict';
-
-  var fetchRetry = function (fetch, defaults) {
-    defaults = defaults || {};
-    if (typeof fetch !== 'function') {
-      throw new ArgumentError('fetch must be a function');
-    }
-
-    if (typeof defaults !== 'object') {
-      throw new ArgumentError('defaults must be an object');
-    }
-
-    if (defaults.retries !== undefined && !isPositiveInteger(defaults.retries)) {
-      throw new ArgumentError('retries must be a positive integer');
-    }
-
-    if (defaults.retryDelay !== undefined && !isPositiveInteger(defaults.retryDelay) && typeof defaults.retryDelay !== 'function') {
-      throw new ArgumentError('retryDelay must be a positive integer or a function returning a positive integer');
-    }
-
-    if (defaults.retryOn !== undefined && !Array.isArray(defaults.retryOn) && typeof defaults.retryOn !== 'function') {
-      throw new ArgumentError('retryOn property expects an array or function');
-    }
-
-    var baseDefaults = {
-      retries: 3,
-      retryDelay: 1000,
-      retryOn: [],
-    };
-
-    defaults = Object.assign(baseDefaults, defaults);
-
-    return function fetchRetry(input, init) {
-      var retries = defaults.retries;
-      var retryDelay = defaults.retryDelay;
-      var retryOn = defaults.retryOn;
-
-      if (init && init.retries !== undefined) {
-        if (isPositiveInteger(init.retries)) {
-          retries = init.retries;
-        } else {
-          throw new ArgumentError('retries must be a positive integer');
-        }
-      }
-
-      if (init && init.retryDelay !== undefined) {
-        if (isPositiveInteger(init.retryDelay) || (typeof init.retryDelay === 'function')) {
-          retryDelay = init.retryDelay;
-        } else {
-          throw new ArgumentError('retryDelay must be a positive integer or a function returning a positive integer');
-        }
-      }
-
-      if (init && init.retryOn) {
-        if (Array.isArray(init.retryOn) || (typeof init.retryOn === 'function')) {
-          retryOn = init.retryOn;
-        } else {
-          throw new ArgumentError('retryOn property expects an array or function');
-        }
-      }
-
-      // eslint-disable-next-line no-undef
-      return new Promise(function (resolve, reject) {
-        var wrappedFetch = function (attempt) {
-          // As of node 18, this is no longer needed since node comes with native support for fetch:
-          /* istanbul ignore next */
-          var _input =
-            typeof Request !== 'undefined' && input instanceof Request
-              ? input.clone()
-              : input;
-          fetch(_input, init)
-            .then(function (response) {
-              if (Array.isArray(retryOn) && retryOn.indexOf(response.status) === -1) {
-                resolve(response);
-              } else if (typeof retryOn === 'function') {
-                try {
-                  // eslint-disable-next-line no-undef
-                  return Promise.resolve(retryOn(attempt, null, response))
-                    .then(function (retryOnResponse) {
-                      if(retryOnResponse) {
-                        retry(attempt, null, response);
-                      } else {
-                        resolve(response);
-                      }
-                    }).catch(reject);
-                } catch (error) {
-                  reject(error);
-                }
-              } else {
-                if (attempt < retries) {
-                  retry(attempt, null, response);
-                } else {
-                  resolve(response);
-                }
-              }
-            })
-            .catch(function (error) {
-              if (typeof retryOn === 'function') {
-                try {
-                  // eslint-disable-next-line no-undef
-                  Promise.resolve(retryOn(attempt, error, null))
-                    .then(function (retryOnResponse) {
-                      if(retryOnResponse) {
-                        retry(attempt, error, null);
-                      } else {
-                        reject(error);
-                      }
-                    })
-                    .catch(function(error) {
-                      reject(error);
-                    });
-                } catch(error) {
-                  reject(error);
-                }
-              } else if (attempt < retries) {
-                retry(attempt, error, null);
-              } else {
-                reject(error);
-              }
-            });
-        };
-
-        function retry(attempt, error, response) {
-          var delay = (typeof retryDelay === 'function') ?
-            retryDelay(attempt, error, response) : retryDelay;
-          setTimeout(function () {
-            wrappedFetch(++attempt);
-          }, delay);
-        }
-
-        wrappedFetch(0);
-      });
-    };
-  };
-
-  function isPositiveInteger(value) {
-    return Number.isInteger(value) && value >= 0;
-  }
-
-  function ArgumentError(message) {
-    this.name = 'ArgumentError';
-    this.message = message;
-  }
-
-  return fetchRetry;
-
-}));

package/node_modules/fetch-retry/index.d.ts

@@ -1,29 +0,0 @@
-declare module 'fetch-retry' {
-  export type FetchLibrary = (input: any, init?: any) => Promise<any>;
-
-  export type RequestDelayFunction<F extends FetchLibrary> = (
-    attempt: number,
-    error: Error | null,
-    response: Awaited<ReturnType<F>> | null,
-  ) => number;
-
-  export type RequestRetryOnFunction<F extends FetchLibrary> = (
-    attempt: number,
-    error: Error | null,
-    response: Awaited<ReturnType<F>> | null,
-  ) => boolean | Promise<boolean>;
-
-  export type RequestInitRetryParams<F extends FetchLibrary> = {
-    retries?: number;
-    retryDelay?: number | RequestDelayFunction<F>;
-    retryOn?: number[] | RequestRetryOnFunction<F>;
-  };
-
-  export type RequestInitWithRetry<F extends FetchLibrary> = Parameters<F>[1] &
-    RequestInitRetryParams<F>;
-
-  export default function fetchBuilder<F extends FetchLibrary>(
-    fetch: F,
-    defaults?: RequestInitRetryParams<F>,
-  ): (input: Parameters<F>[0], init?: RequestInitWithRetry<F>) => ReturnType<F>;
-}