@automattic/vip 4.1.5 → 4.1.8

package/dist/lib/retry.js

@@ -1,24 +1,21 @@
 "use strict";
-
-exports.__esModule = true;
-exports.EXPONENTIAL_BACKOFF_STARTING_IN_50_MS = exports.EXPONENTIAL_BACKOFF_STARTING_IN_200_MS = exports.EXPONENTIAL_BACKOFF_STARTING_IN_100_MS = void 0;
-exports.exponentialBackoff = exponentialBackoff;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EXPONENTIAL_BACKOFF_STARTING_IN_200_MS = exports.EXPONENTIAL_BACKOFF_STARTING_IN_100_MS = exports.EXPONENTIAL_BACKOFF_STARTING_IN_50_MS = void 0;
 exports.retry = retry;
-var _promises = require("node:timers/promises");
+exports.exponentialBackoff = exponentialBackoff;
 // copied over from our internal lib
-
-const EXPONENTIAL_BACKOFF_STARTING_IN_50_MS = exports.EXPONENTIAL_BACKOFF_STARTING_IN_50_MS = exponentialBackoff(50);
-const EXPONENTIAL_BACKOFF_STARTING_IN_100_MS = exports.EXPONENTIAL_BACKOFF_STARTING_IN_100_MS = exponentialBackoff(100);
-const EXPONENTIAL_BACKOFF_STARTING_IN_200_MS = exports.EXPONENTIAL_BACKOFF_STARTING_IN_200_MS = exponentialBackoff(200);
+const promises_1 = require("node:timers/promises");
+exports.EXPONENTIAL_BACKOFF_STARTING_IN_50_MS = exponentialBackoff(50);
+exports.EXPONENTIAL_BACKOFF_STARTING_IN_100_MS = exponentialBackoff(100);
+exports.EXPONENTIAL_BACKOFF_STARTING_IN_200_MS = exponentialBackoff(200);
 const MAX_INTERVAL_BETWEEN_ATTEMPTS = 600000; // 10 minutes
-
-const NOOP = async () => {};
+const NOOP = async () => { };
 const DEFAULT_OPTIONS = {
-  maxRetries: 4,
-  interval: EXPONENTIAL_BACKOFF_STARTING_IN_100_MS,
-  retryOnlyIf: () => Promise.resolve(true),
-  onRetry: NOOP,
-  onFailedAttempt: NOOP
+    maxRetries: 4,
+    interval: exports.EXPONENTIAL_BACKOFF_STARTING_IN_100_MS,
+    retryOnlyIf: () => Promise.resolve(true),
+    onRetry: NOOP,
+    onFailedAttempt: NOOP,
 };
 /**
  * We don't need a strict Error instance, which can help in cases (probably
@@ -26,129 +23,96 @@ const DEFAULT_OPTIONS = {
  * really just need to check for an object with a message property.
  */
 function isErrorLike(value) {
-  return value instanceof Error || null !== value && 'object' === typeof value && 'message' in value;
+    return (value instanceof Error || (null !== value && 'object' === typeof value && 'message' in value));
 }
-
-/**
- * Execute a <task> and retries <options.maxRetries> times while it fails.
- * @param {Object} [options] - The options.
- * @param {number} [options.maxRetries] - The max number of retry attempts to be executed.
- * @param {function|number} [options.interval] - The time to wait between retries in milliseconds.
- *   It can be either a number or a function.
- *   Function arguments: retryAttemptNumber.
- *   Expected return: a number representing the time in milliseconds.
- * @param {function} [options.retryOnlyIf] - A function used to determine if a retry should be attempted.
- *   Arguments: Object<{ error, attemptNumber }>.
- *   Expected return: boolean|Promise<boolean>.
- * @param {function} [options.onRetry] - A callback function executed right before a retry attempt.
- *   Arguments: Object<{ retryNumber: attemptNumber }>.
- *   Expected return: void|Promise<void>.
- * @param {function} [options.onFailedAttempt] - A callback function executed right after a failed attempt.
- *   Arguments: Object<{ error, attemptNumber, attemptDuration }>.
- *   Expected return: void|Promise<void>.
- * @param {function} task - The task to be executed.
- * @return {any} - The value returned by the provided <task> function when it is successfully executed
- */
-
 async function retry(optionsOrTask, task) {
-  let options = optionsOrTask;
-  if (arguments.length < 3 && typeof optionsOrTask === 'function') {
-    task = optionsOrTask;
-    options = {};
-  }
-  const finalOptions = {
-    ...DEFAULT_OPTIONS,
-    ...options
-  };
-  const {
-    maxRetries,
-    interval,
-    retryOnlyIf,
-    onRetry,
-    onFailedAttempt
-  } = finalOptions;
-  validateTask(task);
-  validateOptions(finalOptions);
-  const maxAttempts = maxRetries + 1;
-  for (let attemptNumber = 1; attemptNumber <= maxAttempts; attemptNumber++) {
-    /* eslint-disable no-await-in-loop */
-    const attemptStart = Date.now();
-    try {
-      return await task();
-    } catch (caughtError) {
-      const attemptEnd = Date.now();
-      const attemptDuration = attemptEnd - attemptStart;
-      const attemptStartTime = new Date(attemptStart);
-      const attemptEndTime = new Date(attemptEnd);
-      const error = isErrorLike(caughtError) ? caughtError : new Error(String(caughtError));
-      await onFailedAttempt({
-        error,
-        attemptNumber,
-        attemptDuration,
-        attemptStartTime,
-        attemptEndTime
-      });
-      const shouldRetry = await retryOnlyIf({
-        error,
-        attemptNumber
-      });
-      if (attemptNumber === maxAttempts || shouldRetry !== true) {
-        throw error;
-      }
-      await awaitInterval(interval, attemptNumber);
-      await onRetry({
-        retryNumber: attemptNumber
-      });
+    let options = optionsOrTask;
+    if (arguments.length < 3 && typeof optionsOrTask === 'function') {
+        task = optionsOrTask;
+        options = {};
     }
-  }
-  throw new Error('Error, wrong retry options set');
+    const finalOptions = {
+        ...DEFAULT_OPTIONS,
+        ...options,
+    };
+    const { maxRetries, interval, retryOnlyIf, onRetry, onFailedAttempt } = finalOptions;
+    validateTask(task);
+    validateOptions(finalOptions);
+    const maxAttempts = maxRetries + 1;
+    for (let attemptNumber = 1; attemptNumber <= maxAttempts; attemptNumber++) {
+        /* eslint-disable no-await-in-loop */
+        const attemptStart = Date.now();
+        try {
+            return await task();
+        }
+        catch (caughtError) {
+            const attemptEnd = Date.now();
+            const attemptDuration = attemptEnd - attemptStart;
+            const attemptStartTime = new Date(attemptStart);
+            const attemptEndTime = new Date(attemptEnd);
+            const error = isErrorLike(caughtError) ? caughtError : new Error(String(caughtError));
+            await onFailedAttempt({
+                error,
+                attemptNumber,
+                attemptDuration,
+                attemptStartTime,
+                attemptEndTime,
+            });
+            const shouldRetry = await retryOnlyIf({ error, attemptNumber });
+            if (attemptNumber === maxAttempts || shouldRetry !== true) {
+                throw error;
+            }
+            await awaitInterval(interval, attemptNumber);
+            await onRetry({ retryNumber: attemptNumber });
+        }
+    }
+    throw new Error('Error, wrong retry options set');
 }
 function isValidInterval(interval) {
-  if ('function' === typeof interval) {
-    return true;
-  }
-  return typeof interval === 'number' && Number.isInteger(interval) && interval >= 0 && interval <= MAX_INTERVAL_BETWEEN_ATTEMPTS;
+    if ('function' === typeof interval) {
+        return true;
+    }
+    return (typeof interval === 'number' &&
+        Number.isInteger(interval) &&
+        interval >= 0 &&
+        interval <= MAX_INTERVAL_BETWEEN_ATTEMPTS);
 }
 function awaitInterval(interval, attemptNumber) {
-  let newInterval;
-  if (typeof interval === 'function') {
-    newInterval = interval(attemptNumber);
-    if (!isValidInterval(newInterval)) {
-      throw new Error(`Invalid calculated interval for retry attempt ${attemptNumber}: "${newInterval}" (type: ${typeof newInterval})`);
+    let newInterval;
+    if (typeof interval === 'function') {
+        newInterval = interval(attemptNumber);
+        if (!isValidInterval(newInterval)) {
+            throw new Error(`Invalid calculated interval for retry attempt ${attemptNumber}: "${newInterval}" (type: ${typeof newInterval})`);
+        }
+    }
+    else {
+        newInterval = interval;
     }
-  } else {
-    newInterval = interval;
-  }
-  return (0, _promises.setTimeout)(newInterval);
+    return (0, promises_1.setTimeout)(newInterval);
 }
 function validateTask(task) {
-  if (typeof task !== 'function') {
-    throw new Error('Invalid task: it should be a function');
-  }
+    if (typeof task !== 'function') {
+        throw new Error('Invalid task: it should be a function');
+    }
 }
-function validateOptions({
-  maxRetries,
-  interval,
-  onFailedAttempt,
-  retryOnlyIf
-}) {
-  if (!Number.isInteger(maxRetries) || maxRetries < 0) {
-    throw new Error('Invalid option "maxRetries": it should be an integer number >= 0');
-  }
-  if (!isValidInterval(interval)) {
-    const definition = `an integer number between 0 and ${MAX_INTERVAL_BETWEEN_ATTEMPTS}`;
-    throw new Error(`Invalid option "interval": it should be either ${definition}, or a synchronous function which returns ${definition}`);
-  }
-  if (!isValidInterval(interval)) {
-    throw new Error('Invalid option "interval": it should be either an integer number >= 0, or a synchronous function which returns an integer number >= 0');
-  }
-  if (typeof onFailedAttempt !== 'function') {
-    throw new Error('Invalid option "onFailedAttempt": it should be a function');
-  }
-  if (typeof retryOnlyIf !== 'function') {
-    throw new Error('Invalid option "retryOnlyIf": it should be a function');
-  }
+function validateOptions({ maxRetries, interval, onFailedAttempt, retryOnlyIf, }) {
+    if (!Number.isInteger(maxRetries) || maxRetries < 0) {
+        throw new Error('Invalid option "maxRetries": it should be an integer number >= 0');
+    }
+    if (!isValidInterval(interval)) {
+        const definition = `an integer number between 0 and ${MAX_INTERVAL_BETWEEN_ATTEMPTS}`;
+        throw new Error(`Invalid option "interval": it should be either ${definition}, or a synchronous function which returns ${definition}`);
+    }
+    if (!isValidInterval(interval)) {
+        throw new Error('Invalid option "interval": it should be either an integer number >= 0, or a synchronous function which returns an integer number >= 0');
+    }
+    if (typeof onFailedAttempt !== 'function') {
+        throw new Error('Invalid option "onFailedAttempt": it should be a function');
+    }
+    if (typeof retryOnlyIf !== 'function') {
+        throw new Error('Invalid option "retryOnlyIf": it should be a function');
+    }
 }
 function exponentialBackoff(startMilliseconds) {
-  return retryAttemptNumber => Math.pow(2, retryAttemptNumber - 1) * startMilliseconds;
-}
+    return retryAttemptNumber => Math.pow(2, retryAttemptNumber - 1) * startMilliseconds;
+}

package/dist/lib/search-and-replace.js

@@ -1,157 +1,173 @@
 "use strict";
-
-exports.__esModule = true;
-exports.getReadAndWriteStreams = getReadAndWriteStreams;
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
 exports.searchAndReplace = void 0;
-var _vipSearchReplace = require("@automattic/vip-search-replace");
-var _chalk = _interopRequireDefault(require("chalk"));
-var _debug = _interopRequireDefault(require("debug"));
-var _fs = _interopRequireDefault(require("fs"));
-var _promises = require("node:stream/promises");
-var _path = _interopRequireDefault(require("path"));
-var _database = require("./database");
-var _utils = require("./utils");
-var exit = _interopRequireWildcard(require("../lib/cli/exit"));
-var _prompt = require("../lib/cli/prompt");
-var _clientFileUploader = require("../lib/client-file-uploader");
-var _tracker = require("../lib/tracker");
-function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function (e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || "object" != typeof e && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (const t in e) "default" !== t && {}.hasOwnProperty.call(e, t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, t)) && (i.get || i.set) ? o(f, t, i) : f[t] = e[t]); return f; })(e, t); }
-function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
-const debug = (0, _debug.default)('@automattic/vip:lib:search-and-replace');
-function getReadAndWriteStreams({
-  fileName,
-  inPlace,
-  output
-}) {
-  let writeStream;
-  let usingStdOut = false;
-  let outputFileName;
-  if (inPlace) {
-    const midputFileName = _path.default.join((0, _utils.makeTempDir)('vip-search-replace'), _path.default.basename(fileName));
-    _fs.default.copyFileSync(fileName, midputFileName);
-    debug(`Copied input file to ${midputFileName}`);
-    debug(`Set output to the original file path ${fileName}`);
-    outputFileName = fileName;
+exports.getReadAndWriteStreams = getReadAndWriteStreams;
+const vip_search_replace_1 = require("@automattic/vip-search-replace");
+const chalk_1 = __importDefault(require("chalk"));
+const debug_1 = __importDefault(require("debug"));
+const fs_1 = __importDefault(require("fs"));
+const promises_1 = require("node:stream/promises");
+const path_1 = __importDefault(require("path"));
+const database_1 = require("./database");
+const utils_1 = require("./utils");
+const exit = __importStar(require("../lib/cli/exit"));
+const prompt_1 = require("../lib/cli/prompt");
+const client_file_uploader_1 = require("../lib/client-file-uploader");
+const tracker_1 = require("../lib/tracker");
+const debug = (0, debug_1.default)('@automattic/vip:lib:search-and-replace');
+function getReadAndWriteStreams({ fileName, inPlace, output, }) {
+    let writeStream;
+    let usingStdOut = false;
+    let outputFileName;
+    if (inPlace) {
+        const midputFileName = path_1.default.join((0, utils_1.makeTempDir)('vip-search-replace'), path_1.default.basename(fileName));
+        fs_1.default.copyFileSync(fileName, midputFileName);
+        debug(`Copied input file to ${midputFileName}`);
+        debug(`Set output to the original file path ${fileName}`);
+        outputFileName = fileName;
+        return {
+            outputFileName,
+            readStream: fs_1.default.createReadStream(midputFileName),
+            usingStdOut,
+            writeStream: fs_1.default.createWriteStream(fileName),
+        };
+    }
+    debug(`Reading input from file: ${fileName}`);
+    switch (typeof output) {
+        case 'string':
+            writeStream = fs_1.default.createWriteStream(output);
+            outputFileName = output;
+            debug(`Outputting to file: ${outputFileName}`);
+            break;
+        case 'object':
+            writeStream = output;
+            if (writeStream === process.stdout) {
+                usingStdOut = true;
+                debug('Outputting to the standard output stream');
+            }
+            else {
+                debug('Outputting to the provided output stream');
+            }
+            break;
+        default: {
+            const tmpOutFile = path_1.default.join((0, utils_1.makeTempDir)('vip-search-replace'), path_1.default.basename(fileName));
+            writeStream = fs_1.default.createWriteStream(tmpOutFile);
+            outputFileName = tmpOutFile;
+            debug(`Outputting to file: ${outputFileName}`);
+            break;
+        }
+    }
     return {
-      outputFileName,
-      readStream: _fs.default.createReadStream(midputFileName),
-      usingStdOut,
-      writeStream: _fs.default.createWriteStream(fileName)
+        outputFileName,
+        readStream: fs_1.default.createReadStream(fileName),
+        usingStdOut,
+        writeStream,
     };
-  }
-  debug(`Reading input from file: ${fileName}`);
-  switch (typeof output) {
-    case 'string':
-      writeStream = _fs.default.createWriteStream(output);
-      outputFileName = output;
-      debug(`Outputting to file: ${outputFileName}`);
-      break;
-    case 'object':
-      writeStream = output;
-      if (writeStream === process.stdout) {
-        usingStdOut = true;
-        debug('Outputting to the standard output stream');
-      } else {
-        debug('Outputting to the provided output stream');
-      }
-      break;
-    default:
-      {
-        const tmpOutFile = _path.default.join((0, _utils.makeTempDir)('vip-search-replace'), _path.default.basename(fileName));
-        writeStream = _fs.default.createWriteStream(tmpOutFile);
-        outputFileName = tmpOutFile;
-        debug(`Outputting to file: ${outputFileName}`);
-        break;
-      }
-  }
-  return {
-    outputFileName,
-    readStream: _fs.default.createReadStream(fileName),
-    usingStdOut,
-    writeStream
-  };
 }
-const searchAndReplace = async (fileName, pairs, {
-  isImport = true,
-  inPlace = false,
-  output = process.stdout,
-  batchMode = false
-}, binary = null) => {
-  const dumpDetails = await (0, _database.getSqlDumpDetails)(fileName);
-  const isMyDumper = dumpDetails.type === _database.SqlDumpType.MYDUMPER;
-  await (0, _tracker.trackEvent)('searchreplace_started', {
-    is_import: isImport,
-    in_place: inPlace,
-    sqldump_type: dumpDetails.type
-  });
-  const startTime = process.hrtime();
-  const fileSize = (0, _clientFileUploader.getFileSize)(fileName);
-
-  // if we don't have any pairs to replace with, return the input file
-  if (!pairs.length) {
-    throw new Error('No search and replace parameters provided.');
-  }
-
-  // If only one pair is provided, ensure we have an array
-  if (!Array.isArray(pairs)) {
-    pairs = [pairs];
-  }
-
-  // determine all the replacements required
-  const replacements = pairs.flatMap(pair => pair.split(',').map(str => str.trim()));
-  debug('Pairs: ', pairs, 'Replacements: ', replacements);
-  if (inPlace && !batchMode) {
-    const approved = await (0, _prompt.confirm)([], 'Are you sure you want to run search and replace on your input file? This operation is not reversible.');
-
-    // Bail if user does not wish to proceed
-    if (!approved) {
-      await (0, _tracker.trackEvent)('search_replace_in_place_cancelled', {
+const searchAndReplace = async (fileName, pairs, { isImport = true, inPlace = false, output = process.stdout, batchMode = false, }, binary = null) => {
+    const dumpDetails = await (0, database_1.getSqlDumpDetails)(fileName);
+    const isMyDumper = dumpDetails.type === database_1.SqlDumpType.MYDUMPER;
+    await (0, tracker_1.trackEvent)('searchreplace_started', {
         is_import: isImport,
         in_place: inPlace,
-        sqldump_type: dumpDetails.type
-      });
-      process.exit();
+        sqldump_type: dumpDetails.type,
+    });
+    const startTime = process.hrtime();
+    const fileSize = (0, client_file_uploader_1.getFileSize)(fileName);
+    // if we don't have any pairs to replace with, return the input file
+    if (!pairs.length) {
+        throw new Error('No search and replace parameters provided.');
+    }
+    // If only one pair is provided, ensure we have an array
+    if (!Array.isArray(pairs)) {
+        pairs = [pairs];
     }
-  }
-  const {
-    usingStdOut,
-    outputFileName,
-    readStream,
-    writeStream
-  } = getReadAndWriteStreams({
-    fileName,
-    inPlace,
-    output
-  });
-  let replacedStream;
-  try {
-    replacedStream = await (0, _vipSearchReplace.replace)(readStream, replacements, binary);
-  } catch (replaceError) {
-    // replace() throws strings... OMG
-    exit.withError(replaceError);
-  }
-  const transforms = [];
-  if (isMyDumper) {
-    transforms.push((0, _database.fixMyDumperTransform)());
-  }
-  try {
-    await (0, _promises.pipeline)(replacedStream, ...transforms, writeStream);
-  } catch (error) {
-    console.log(_chalk.default.red("Oh no! We couldn't write to the output file.  Please check your available disk space and file/folder permissions."));
-    throw error;
-  }
-  const endTime = process.hrtime(startTime);
-  const end = endTime[1] / 1000000; // time in ms
-
-  await (0, _tracker.trackEvent)('searchreplace_completed', {
-    time_to_run: end,
-    file_size: fileSize,
-    sqldump_type: dumpDetails.type
-  });
-  return {
-    inputFileName: fileName,
-    outputFileName,
-    usingStdOut
-  };
+    // determine all the replacements required
+    const replacements = pairs.flatMap(pair => pair.split(',').map(str => str.trim()));
+    debug('Pairs: ', pairs, 'Replacements: ', replacements);
+    if (inPlace && !batchMode) {
+        const approved = await (0, prompt_1.confirm)([], 'Are you sure you want to run search and replace on your input file? This operation is not reversible.');
+        // Bail if user does not wish to proceed
+        if (!approved) {
+            await (0, tracker_1.trackEvent)('search_replace_in_place_cancelled', {
+                is_import: isImport,
+                in_place: inPlace,
+                sqldump_type: dumpDetails.type,
+            });
+            process.exit();
+        }
+    }
+    const { usingStdOut, outputFileName, readStream, writeStream } = getReadAndWriteStreams({
+        fileName,
+        inPlace,
+        output,
+    });
+    let replacedStream;
+    try {
+        replacedStream = await (0, vip_search_replace_1.replace)(readStream, replacements, binary);
+    }
+    catch (replaceError) {
+        // replace() throws strings... OMG
+        exit.withError(replaceError);
+    }
+    const transforms = [];
+    if (isMyDumper) {
+        transforms.push((0, database_1.fixMyDumperTransform)());
+    }
+    try {
+        await (0, promises_1.pipeline)(replacedStream, ...transforms, writeStream);
+    }
+    catch (error) {
+        console.log(chalk_1.default.red("Oh no! We couldn't write to the output file.  Please check your available disk space and file/folder permissions."));
+        throw error;
+    }
+    const endTime = process.hrtime(startTime);
+    const end = endTime[1] / 1000000; // time in ms
+    await (0, tracker_1.trackEvent)('searchreplace_completed', {
+        time_to_run: end,
+        file_size: fileSize,
+        sqldump_type: dumpDetails.type,
+    });
+    return {
+        inputFileName: fileName,
+        outputFileName,
+        usingStdOut,
+    };
 };
-exports.searchAndReplace = searchAndReplace;
+exports.searchAndReplace = searchAndReplace;

package/dist/lib/site-import/db-file-import.js

@@ -1,21 +1,17 @@
 "use strict";
-
-exports.__esModule = true;
-exports.SYNC_STATUS_NOT_SYNCING = exports.SQL_IMPORT_FILE_SIZE_LIMIT_LAUNCHED = exports.SQL_IMPORT_FILE_SIZE_LIMIT = void 0;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isImportingBlockedBySync = exports.SYNC_STATUS_NOT_SYNCING = exports.isSupportedApp = exports.SQL_IMPORT_FILE_SIZE_LIMIT_LAUNCHED = exports.SQL_IMPORT_FILE_SIZE_LIMIT = void 0;
 exports.currentUserCanImportForApp = currentUserCanImportForApp;
-exports.isSupportedApp = exports.isImportingBlockedBySync = void 0;
-var _fileSize = require("../../lib/constants/file-size");
-var _vipgo = require("../../lib/constants/vipgo");
-const SQL_IMPORT_FILE_SIZE_LIMIT = exports.SQL_IMPORT_FILE_SIZE_LIMIT = 200 * _fileSize.GB_IN_BYTES;
-const SQL_IMPORT_FILE_SIZE_LIMIT_LAUNCHED = exports.SQL_IMPORT_FILE_SIZE_LIMIT_LAUNCHED = 10 * _fileSize.GB_IN_BYTES;
+const file_size_1 = require("../../lib/constants/file-size");
+const vipgo_1 = require("../../lib/constants/vipgo");
+exports.SQL_IMPORT_FILE_SIZE_LIMIT = 200 * file_size_1.GB_IN_BYTES;
+exports.SQL_IMPORT_FILE_SIZE_LIMIT_LAUNCHED = 10 * file_size_1.GB_IN_BYTES;
 function currentUserCanImportForApp(app) {
-  // TODO: implement
-  return Boolean(app);
+    // TODO: implement
+    return Boolean(app);
 }
-const isSupportedApp = ({
-  typeId
-}) => _vipgo.DATABASE_APPLICATION_TYPE_IDS.includes(typeId);
+const isSupportedApp = ({ typeId }) => vipgo_1.DATABASE_APPLICATION_TYPE_IDS.includes(typeId);
 exports.isSupportedApp = isSupportedApp;
-const SYNC_STATUS_NOT_SYNCING = exports.SYNC_STATUS_NOT_SYNCING = 'not_syncing';
-const isImportingBlockedBySync = env => env.syncProgress?.status !== SYNC_STATUS_NOT_SYNCING;
-exports.isImportingBlockedBySync = isImportingBlockedBySync;
+exports.SYNC_STATUS_NOT_SYNCING = 'not_syncing';
+const isImportingBlockedBySync = (env) => env.syncProgress?.status !== exports.SYNC_STATUS_NOT_SYNCING;
+exports.isImportingBlockedBySync = isImportingBlockedBySync;