convex/dist/cjs/bundler/context.js

Client for the Convex Cloud

"use strict";
var __create = Object.create;
var __defProp = Object.defineProperty;
var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
var __getOwnPropNames = Object.getOwnPropertyNames;
var __getProtoOf = Object.getPrototypeOf;
var __hasOwnProp = Object.prototype.hasOwnProperty;
var __export = (target, all) => {
  for (var name in all)
    __defProp(target, name, { get: all[name], enumerable: true });
};
var __copyProps = (to, from, except, desc) => {
  if (from && typeof from === "object" || typeof from === "function") {
    for (let key of __getOwnPropNames(from))
      if (!__hasOwnProp.call(to, key) && key !== except)
        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
  }
  return to;
};
var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
  // If the importer is in node compatibility mode or this is not an ESM
  // file that has been converted to a CommonJS file using a Babel-
  // compatible transform (i.e. "__esModule" has not been set), then set
  // "default" to the CommonJS "module.exports" for node compatibility.
  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
  mod
));
var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
var context_exports = {};
__export(context_exports, {
  changeSpinner: () => changeSpinner,
  logError: () => logError,
  logFailure: () => logFailure,
  logFinishedStep: () => logFinishedStep,
  logMessage: () => logMessage,
  logOutput: () => logOutput,
  logWarning: () => logWarning,
  oneoffContext: () => oneoffContext,
  showSpinner: () => showSpinner,
  showSpinnerIfSlow: () => showSpinnerIfSlow,
  stopSpinner: () => stopSpinner
});
module.exports = __toCommonJS(context_exports);
var Sentry = __toESM(require("@sentry/node"), 1);
var import_chalk = __toESM(require("chalk"), 1);
var import_ora = __toESM(require("ora"), 1);
var import_fs = require("./fs.js");
const oneoffContext = {
  fs: import_fs.nodeFs,
  deprecationMessagePrinted: false,
  spinner: void 0,
  async crash(exitCode, _errorType, err) {
    return await flushAndExit(exitCode, err);
  }
};
async function flushAndExit(exitCode, err) {
  if (err) {
    Sentry.captureException(err);
  }
  await Sentry.close();
  return process.exit(exitCode);
}
function logError(ctx, message) {
  ctx.spinner?.clear();
  console.error(message);
}
function logWarning(ctx, message) {
  ctx.spinner?.clear();
  console.error(message);
}
function logMessage(ctx, ...logged) {
  ctx.spinner?.clear();
  console.error(...logged);
}
function logOutput(ctx, ...logged) {
  ctx.spinner?.clear();
  console.log(...logged);
}
function showSpinner(ctx, message) {
  ctx.spinner?.stop();
  ctx.spinner = (0, import_ora.default)({
    // Add newline to prevent clobbering when a message
    // we can't pipe through `logMessage` et al gets printed
    text: message + "\n",
    stream: process.stderr
  }).start();
}
function changeSpinner(ctx, message) {
  if (ctx.spinner) {
    ctx.spinner.text = message + "\n";
  } else {
    console.error(message);
  }
}
function logFailure(ctx, message) {
  if (ctx.spinner) {
    ctx.spinner.fail(message);
    ctx.spinner = void 0;
  } else {
    console.error(`${import_chalk.default.red(`\u2716`)} ${message}`);
  }
}
function logFinishedStep(ctx, message) {
  if (ctx.spinner) {
    ctx.spinner.succeed(message);
    ctx.spinner = void 0;
  } else {
    console.error(`${import_chalk.default.green(`\u2714`)} ${message}`);
  }
}
function stopSpinner(ctx) {
  if (ctx.spinner) {
    ctx.spinner.stop();
    ctx.spinner = void 0;
  }
}
async function showSpinnerIfSlow(ctx, message, delayMs, fn) {
  const timeout = setTimeout(() => {
    showSpinner(ctx, message);
  }, delayMs);
  await fn();
  clearTimeout(timeout);
}
//# sourceMappingURL=context.js.map