@sentry/wizard 3.4.0 → 3.6.0

package/src/sourcemaps/utils/sdk-version.ts

@@ -0,0 +1,257 @@
+// @ts-ignore - clack is ESM and TS complains about that. It works though
+import clack from '@clack/prompts';
+import chalk from 'chalk';
+import { minVersion, satisfies } from 'semver';
+import {
+  abortIfCancelled,
+  getPackageDotJson,
+  installPackage,
+} from '../../utils/clack-utils';
+
+import * as Sentry from '@sentry/node';
+import { findInstalledPackageFromList } from '../../utils/package-json';
+
+const MINIMUM_DEBUG_ID_SDK_VERSION = '7.47.0';
+
+// This array is orderd by the SDKs we want to check for first.
+// The reason is that some SDKs depend on others and some users might
+// have added the dependencies to their package.json. We want to make sure
+// that we actually detect the "top-level" SDK first.
+const SENTRY_SDK_PACKAGE_NAMES = [
+  // SDKs using other framework SDKs need to be checked first
+  '@sentry/gatsby',
+  '@sentry/nextjs',
+  '@sentry/remix',
+  '@sentry/sveltekit',
+
+  // Framework SDKs
+  '@sentry/angular',
+  '@sentry/angular-ivy',
+  '@sentry/ember',
+  '@sentry/react',
+  '@sentry/svelte',
+  '@sentry/vue',
+  '@sentry/serverless',
+
+  // Base SDKs
+  '@sentry/browser',
+  '@sentry/node',
+];
+
+/**
+ * Check for a minimum SDK version and prompt the user to upgrade if necessary.
+ * We distinguish between 4 cases here:
+ *
+ * 1. Users didn't install any SDK yet
+ *    -> We tell them to install an SDK and then continue with the wizard
+ * 2. Users installed an SDK in the range >=7.47.0
+ *    -> All good, no need to do anything!
+ * 3. Users installed an SDK in the range >=7.0.0 <= 7.46.0
+ *    -> We ask if they want to auto-update to the latest version
+ * 4. Users installed an SDK in the range <7.x
+ *    -> We tell users to manually upgrade (migrate between majors)
+ */
+export async function ensureMinimumSdkVersionIsInstalled(): Promise<void> {
+  const installedSdkPackage = findInstalledPackageFromList(
+    SENTRY_SDK_PACKAGE_NAMES,
+    await getPackageDotJson(),
+  );
+
+  // Case 1:
+  if (!installedSdkPackage) {
+    return await handleNoSdkInstalled();
+  }
+
+  const { name: installedSdkName, version: installedSdkVersionOrRange } =
+    installedSdkPackage;
+
+  Sentry.setTag('installed-sdk', installedSdkName);
+
+  const minInstalledVersion = getMinInstalledVersion(
+    installedSdkVersionOrRange,
+    installedSdkName,
+  );
+
+  if (!minInstalledVersion) {
+    // This is handled in the getMinInstalledVersion function
+    return;
+  }
+
+  const hasDebugIdCompatibleSdkVersion = satisfies(
+    minInstalledVersion,
+    `>=${MINIMUM_DEBUG_ID_SDK_VERSION}`,
+  );
+
+  // Case 2:
+  if (hasDebugIdCompatibleSdkVersion) {
+    Sentry.setTag('initial-sdk-version', '>=7.47.0');
+    return;
+  }
+
+  const hasV7SdkVersion = satisfies(minInstalledVersion, '>=7.0.0');
+
+  clack.log.warn(
+    `${chalk.yellowBright(
+      `It seems like you're using an outdated version (${installedSdkVersionOrRange}) of the ${chalk.bold(
+        installedSdkName,
+      )} SDK.`,
+    )}
+Uploading source maps is easiest with an SDK from version ${chalk.bold(
+      MINIMUM_DEBUG_ID_SDK_VERSION,
+    )} or newer.    
+`,
+  );
+
+  // Case 3:
+  if (hasV7SdkVersion) {
+    await handleAutoUpdateSdk(installedSdkName);
+    return;
+  }
+
+  // Case 4:
+  await handleManuallyUpdateSdk(minInstalledVersion);
+}
+
+async function handleManuallyUpdateSdk(minInstalledVersion: string) {
+  Sentry.setTag(
+    'initial-sdk-version',
+    `${satisfies(minInstalledVersion, '>=6.0.0') ? '6.x' : '<6.0.0'}`,
+  );
+
+  clack.log
+    .info(`When upgrading from a version older than 7.0.0, make sure to follow the migration guide:
+https://github.com/getsentry/sentry-javascript/blob/develop/MIGRATION.md#upgrading-from-6x-to-7x
+`);
+
+  const didUpdate = await abortIfCancelled(
+    clack.select({
+      message: 'Did you update your SDK to the latest version?',
+      options: [
+        {
+          label: 'Yes!',
+          value: true,
+        },
+        {
+          label: "No, I'll do it later...",
+          value: false,
+          hint: chalk.yellow(
+            `Remember to update your SDK to at least ${MINIMUM_DEBUG_ID_SDK_VERSION}.`,
+          ),
+        },
+      ],
+      initialValue: true,
+    }),
+  );
+
+  Sentry.setTag(
+    'resolved-sdk-status',
+    didUpdate ? 'updated-manually' : 'update-later',
+  );
+}
+
+async function handleAutoUpdateSdk(packageName: string) {
+  Sentry.setTag('initial-sdk-version', '>=7.0.0 <7.47.0');
+
+  const shouldUpdate = await abortIfCancelled(
+    clack.select({
+      message:
+        'Do you want to automatically update your SDK to the latest version?',
+      options: [
+        {
+          label: 'Yes!',
+          value: true,
+          hint: chalk.green('Recommended'),
+        },
+        {
+          label: "No, I'll do it later...",
+          value: false,
+          hint: chalk.yellow(
+            `Remember to update your SDK to at least ${MINIMUM_DEBUG_ID_SDK_VERSION}.`,
+          ),
+        },
+      ],
+      initialValue: true,
+    }),
+  );
+
+  if (shouldUpdate) {
+    await installPackage({
+      packageName,
+      alreadyInstalled: true,
+      askBeforeUpdating: false, // we already did this above
+    });
+  }
+
+  Sentry.setTag(
+    'resolved-sdk-status',
+    shouldUpdate ? 'updated-automatically' : 'update-later',
+  );
+}
+
+async function handleNoSdkInstalled(): Promise<void> {
+  Sentry.setTag('initial-sdk-version', 'none');
+  Sentry.setTag('installed-sdk', 'none');
+
+  clack.log.warn(
+    `${chalk.yellowBright(
+      `It seems like you didn't yet install a Sentry SDK in your project.`,
+    )}
+We recommend setting up the SDK before continuing with the source maps wizard.
+
+${chalk.dim(`Take a look at our docs to get started:
+https://docs.sentry.io/`)}`,
+  );
+
+  const installedSDK = await abortIfCancelled(
+    clack.select({
+      message: 'Did you set up your Sentry SDK?',
+      options: [
+        { label: 'Yes, continue!', value: true },
+        {
+          label: "I'll do it later...",
+          value: false,
+          hint: chalk.yellow(
+            'You need to set up an SDK before you can use Sentry',
+          ),
+        },
+      ],
+      initialValue: true,
+    }),
+  );
+
+  Sentry.setTag(
+    'resolved-sdk-status',
+    installedSDK ? 'installed-manually' : 'install-later',
+  );
+}
+
+function getMinInstalledVersion(
+  installedSdkVersionOrRange: string,
+  installedSdkName: string,
+): string | undefined {
+  try {
+    // If `minVersion` is unable to parse the version it will throw an error
+    // However, it will also return `null` if the parameter is undefined, which
+    // we explicitly checked before but the typing doesn't know that.
+    const minInstalledVersion = minVersion(installedSdkVersionOrRange)?.version;
+    if (minInstalledVersion) {
+      return minInstalledVersion;
+    }
+  } catch {
+    // handling this, along with the `null` case below
+  }
+
+  Sentry.setTag('initial-sdk-version', 'unknown');
+  clack.log.warn(
+    `${chalk.yellow(
+      `Could not parse the version of your installed SDK ("${installedSdkName}": "${installedSdkVersionOrRange}")`,
+    )}
+
+Please make sure that your Sentry SDK is updated to version ${chalk.bold(
+      MINIMUM_DEBUG_ID_SDK_VERSION,
+    )} or newer.
+    `,
+  );
+
+  return undefined;
+}

package/src/sveltekit/sveltekit-wizard.ts

@@ -9,21 +9,18 @@ import {
   confirmContinueEvenThoughNoGitRepo,
   ensurePackageIsInstalled,
   getPackageDotJson,
-  hasPackageInstalled,
   installPackage,
   printWelcome,
 } from '../utils/clack-utils';
+import { hasPackageInstalled } from '../utils/package-json';
+import { WizardOptions } from '../utils/types';
 import { createExamplePage } from './sdk-example';
 import { createOrMergeSvelteKitFiles, loadSvelteConfig } from './sdk-setup';
 
 import { setupCLIConfig } from './sentry-cli-setup';
 
-interface SvelteKitWizardOptions {
-  promoCode?: string;
-}
-
 export async function runSvelteKitWizard(
-  options: SvelteKitWizardOptions,
+  options: WizardOptions,
 ): Promise<void> {
   printWelcome({
     wizardName: 'Sentry SvelteKit Wizard',
@@ -35,7 +32,7 @@ export async function runSvelteKitWizard(
   const packageJson = await getPackageDotJson();
   await ensurePackageIsInstalled(packageJson, '@sveltejs/kit', 'Sveltekit');
 
-  const { url: sentryUrl, selfHosted } = await askForSelfHosted();
+  const { url: sentryUrl, selfHosted } = await askForSelfHosted(options.url);
 
   const { projects, apiKeys } = await askForWizardLogin({
     promoCode: options.promoCode,

package/src/telemetry.ts

@@ -6,6 +6,7 @@ import {
   makeNodeTransport,
   NodeClient,
   runWithAsyncContext,
+  trace,
 } from '@sentry/node';
 import packageJson from '../package.json';
 
@@ -26,6 +27,7 @@ export async function withTelemetry<F>(
   const transaction = sentryHub.startTransaction({
     name: 'sentry-wizard-execution',
     status: 'ok',
+    op: 'wizard.flow',
   });
   sentryHub.getScope().setSpan(transaction);
   const sentrySession = sentryHub.startSession();
@@ -74,6 +76,8 @@ function createSentryInstance(enabled: boolean, integration: string) {
     },
 
     transport: makeNodeTransport,
+
+    debug: true,
   });
 
   const hub = new Hub(client);
@@ -84,3 +88,7 @@ function createSentryInstance(enabled: boolean, integration: string) {
 
   return { sentryHub: hub, sentryClient: client };
 }
+
+export function traceStep<T>(step: string, callback: () => T): T {
+  return trace({ name: step, op: 'wizard.step' }, () => callback());
+}

package/src/utils/bash.ts

@@ -0,0 +1,44 @@
+import * as child_process from 'child_process';
+import * as https from 'https';
+import * as fs from 'fs';
+
+export function hasSentryCLI(): boolean {
+    try {
+        child_process.execSync('sentry-cli --version');
+        return true;
+    } catch (e) {
+        return false;
+    }
+}
+
+export async function installSentryCLI(): Promise<void> {
+    const httpAsync = new Promise((resolve, reject) => {
+        const file = fs.createWriteStream('installcli.sh');
+        https.get('https://sentry.io/get-cli/', (response) => {
+            response.pipe(file);
+            file.on('finish', () => {
+                file.close();
+                try {
+                    child_process.execSync('bash ./installcli.sh');
+                } catch (e) {
+                    reject(e);
+                    return
+                }
+                fs.unlinkSync('installcli.sh');
+                resolve(null);
+            });
+
+            file.on('error', (err) => {
+                fs.unlinkSync('installcli.sh');
+                reject(err);
+            });
+        });
+    });
+
+    await httpAsync;
+}
+
+export function execute(command: string): string {
+    const output = child_process.execSync(command);
+    return output.toString();
+}

package/src/utils/clack-utils.ts

@@ -10,6 +10,11 @@ import { URL } from 'url';
 import { promisify } from 'util';
 import * as Sentry from '@sentry/node';
 import { windowedSelect } from './vendor/clack-custom-select';
+import { hasPackageInstalled, PackageDotJson } from './package-json';
+
+const opn = require('opn') as (
+  url: string,
+) => Promise<childProcess.ChildProcess>;
 
 const SAAS_URL = 'https://sentry.io/';
 
@@ -20,16 +25,11 @@ interface WizardProjectData {
   projects: SentryProjectData[];
 }
 
-export type PackageDotJson = {
-  scripts?: Record<string, string>;
-  dependencies?: Record<string, string>;
-  devDependencies?: Record<string, string>;
-};
-
 export interface SentryProjectData {
   id: string;
   slug: string;
   name: string;
+  platform: string;
   organization: {
     slug: string;
   };
@@ -126,10 +126,16 @@ export async function confirmContinueEvenThoughNoGitRepo(): Promise<void> {
   }
 }
 
+export async function askToInstallSentryCLI(): Promise<boolean> {
+  return await abortIfCancelled(clack.confirm({
+    message: "You don't have Sentry CLI installed. Do you want to install it?"
+  }));
+}
+
 export async function askForWizardLogin(options: {
   url: string;
   promoCode?: string;
-  platform?: 'javascript-nextjs' | 'javascript-sveltekit';
+  platform?: 'javascript-nextjs' | 'javascript-sveltekit' | 'apple-ios';
 }): Promise<WizardProjectData> {
   Sentry.setTag('has-promo-code', !!options.promoCode);
 
@@ -179,14 +185,18 @@ export async function askForWizardLogin(options: {
     loginUrl.searchParams.set('code', options.promoCode);
   }
 
+  const urlToOpen = loginUrl.toString();
   clack.log.info(
     `${chalk.bold(
-      `Please open the following link in your browser to ${
-        hasSentryAccount ? 'log' : 'sign'
+      `If the browser window didn't open automatically, please open the following link to ${hasSentryAccount ? 'log' : 'sign'
       } into Sentry:`,
-    )}\n\n${chalk.cyan(loginUrl.toString())}`,
+    )}\n\n${chalk.cyan(urlToOpen)}`,
   );
 
+  opn(urlToOpen).catch(() => {
+    // opn throws in environments that don't have a browser (e.g. remote shells) so we just noop here
+  });
+
   const loginSpinner = clack.spinner();
 
   loginSpinner.start(
@@ -225,6 +235,23 @@ export async function askForWizardLogin(options: {
   return data;
 }
 
+export async function askForItemSelection(items: string[], message: string): Promise<{ value: string, index: number }> {
+  const selection: { value: string, index: number } | symbol = await abortIfCancelled(
+    windowedSelect({
+      maxItems: 12,
+      message: message,
+      options: items.map((item, index) => {
+        return {
+          value: { value: item, index: index },
+          label: item,
+        };
+      }),
+    }),
+  );
+
+  return selection;
+}
+
 export async function askForProjectSelection(
   projects: SentryProjectData[],
 ): Promise<SentryProjectData> {
@@ -242,6 +269,7 @@ export async function askForProjectSelection(
   );
 
   Sentry.setTag('project', selection.slug);
+  Sentry.setTag('project-platform', selection.platform);
   Sentry.setUser({ id: selection.organization.slug });
 
   return selection;
@@ -250,11 +278,13 @@ export async function askForProjectSelection(
 export async function installPackage({
   packageName,
   alreadyInstalled,
+  askBeforeUpdating = true,
 }: {
   packageName: string;
   alreadyInstalled: boolean;
+  askBeforeUpdating?: boolean;
 }): Promise<void> {
-  if (alreadyInstalled) {
+  if (alreadyInstalled && askBeforeUpdating) {
     const shouldUpdatePackage = await abortIfCancelled(
       clack.confirm({
         message: `The ${chalk.bold.cyan(
@@ -306,34 +336,54 @@ export async function installPackage({
   );
 }
 
-export async function askForSelfHosted(): Promise<{
+/**
+ * Asks users if they are using SaaS or self-hosted Sentry and returns the validated URL.
+ *
+ * If users started the wizard with a --url arg, that URL is used as the default and we skip
+ * the self-hosted question. However, the passed url is still validated and in case it's
+ * invalid, users are asked to enter a new one until it is valid.
+ *
+ * @param urlFromArgs the url passed via the --url arg
+ */
+export async function askForSelfHosted(urlFromArgs?: string): Promise<{
   url: string;
   selfHosted: boolean;
 }> {
-  const choice: 'saas' | 'self-hosted' | symbol = await abortIfCancelled(
-    clack.select({
-      message: 'Are you using Sentry SaaS or self-hosted Sentry?',
-      options: [
-        { value: 'saas', label: 'Sentry SaaS (sentry.io)' },
-        { value: 'self-hosted', label: 'Self-hosted/on-premise/single-tenant' },
-      ],
-    }),
-  );
+  if (!urlFromArgs) {
+    const choice: 'saas' | 'self-hosted' | symbol = await abortIfCancelled(
+      clack.select({
+        message: 'Are you using Sentry SaaS or self-hosted Sentry?',
+        options: [
+          { value: 'saas', label: 'Sentry SaaS (sentry.io)' },
+          {
+            value: 'self-hosted',
+            label: 'Self-hosted/on-premise/single-tenant',
+          },
+        ],
+      }),
+    );
 
-  if (choice === 'saas') {
-    Sentry.setTag('url', SAAS_URL);
-    Sentry.setTag('self-hosted', false);
-    return { url: SAAS_URL, selfHosted: false };
+    if (choice === 'saas') {
+      Sentry.setTag('url', SAAS_URL);
+      Sentry.setTag('self-hosted', false);
+      return { url: SAAS_URL, selfHosted: false };
+    }
   }
 
   let validUrl: string | undefined;
+  let tmpUrlFromArgs = urlFromArgs;
+
   while (validUrl === undefined) {
-    const url = await abortIfCancelled(
-      clack.text({
-        message: 'Please enter the URL of your self-hosted Sentry instance.',
-        placeholder: 'https://sentry.io/',
-      }),
-    );
+    const url =
+      tmpUrlFromArgs ||
+      (await abortIfCancelled(
+        clack.text({
+          message: `Please enter the URL of your ${urlFromArgs ? '' : 'self-hosted '
+            }Sentry instance.`,
+          placeholder: 'https://sentry.io/',
+        }),
+      ));
+    tmpUrlFromArgs = undefined;
 
     try {
       validUrl = new URL(url).toString();
@@ -344,13 +394,16 @@ export async function askForSelfHosted(): Promise<{
       }
     } catch {
       clack.log.error(
-        'Please enter a valid URL. (It should look something like "http://sentry.mydomain.com/")',
+        'Please enter a valid URL. (It should look something like "https://sentry.mydomain.com/")',
       );
     }
   }
 
+  const isSelfHostedUrl = new URL(validUrl).host !== new URL(SAAS_URL).host;
+
   Sentry.setTag('url', validUrl);
-  Sentry.setTag('self-hosted', true);
+  Sentry.setTag('self-hosted', isSelfHostedUrl);
+
   return { url: validUrl, selfHosted: true };
 }
 
@@ -549,25 +602,8 @@ export async function getPackageDotJson(): Promise<PackageDotJson> {
   return packageJson || {};
 }
 
-export function hasPackageInstalled(
-  packageName: string,
-  packageJson: PackageDotJson,
-): boolean {
-  return (
-    !!packageJson?.dependencies?.[packageName] ||
-    !!packageJson?.devDependencies?.[packageName]
-  );
-}
-
 async function getPackageManager(): Promise<string> {
-  let detectedPackageManager;
-  if (fs.existsSync(path.join(process.cwd(), 'yarn.lock'))) {
-    detectedPackageManager = 'yarn';
-  } else if (fs.existsSync(path.join(process.cwd(), 'package-lock.json'))) {
-    detectedPackageManager = 'npm';
-  } else if (fs.existsSync(path.join(process.cwd(), 'pnpm-lock.yaml'))) {
-    detectedPackageManager = 'pnpm';
-  }
+  const detectedPackageManager = detectPackageManager();
 
   if (detectedPackageManager) {
     return detectedPackageManager;
@@ -588,3 +624,16 @@ async function getPackageManager(): Promise<string> {
 
   return selectedPackageManager;
 }
+
+export function detectPackageManager(): 'yarn' | 'npm' | 'pnpm' | undefined {
+  if (fs.existsSync(path.join(process.cwd(), 'yarn.lock'))) {
+    return 'yarn';
+  }
+  if (fs.existsSync(path.join(process.cwd(), 'package-lock.json'))) {
+    return 'npm';
+  }
+  if (fs.existsSync(path.join(process.cwd(), 'pnpm-lock.yaml'))) {
+    return 'pnpm';
+  }
+  return undefined;
+}

package/src/utils/package-json.ts

@@ -0,0 +1,45 @@
+export type PackageDotJson = {
+  scripts?: Record<string, string>;
+  dependencies?: Record<string, string>;
+  devDependencies?: Record<string, string>;
+};
+
+type NpmPackage = {
+  name: string;
+  version: string;
+};
+
+/**
+ * Checks if @param packageJson has any of the @param packageNamesList package names
+ * listed as a dependency or devDependency.
+ * If so, it returns the first package name that is found, including the
+ * version (range) specified in the package.json.
+ */
+export function findInstalledPackageFromList(
+  packageNamesList: string[],
+  packageJson: PackageDotJson,
+): NpmPackage | undefined {
+  return packageNamesList
+    .map((packageName) => ({
+      name: packageName,
+      version: getPackageVersion(packageName, packageJson),
+    }))
+    .find((sdkPackage): sdkPackage is NpmPackage => !!sdkPackage.version);
+}
+
+export function hasPackageInstalled(
+  packageName: string,
+  packageJson: PackageDotJson,
+): boolean {
+  return getPackageVersion(packageName, packageJson) !== undefined;
+}
+
+export function getPackageVersion(
+  packageName: string,
+  packageJson: PackageDotJson,
+): string | undefined {
+  return (
+    packageJson?.dependencies?.[packageName] ||
+    packageJson?.devDependencies?.[packageName]
+  );
+}

package/src/utils/types.ts

@@ -0,0 +1,18 @@
+export type WizardOptions = {
+  /**
+   * Controls whether the wizard should send telemetry data to Sentry.
+   */
+  telemetryEnabled: boolean;
+
+  /**
+   * The promo code to use while signing up for Sentry.
+   * This can be passed via the --promo-code arg.
+   */
+  promoCode?: string;
+
+  /**
+   * The url of the Sentry instance to use.
+   * This can be passed via the `-u` or `--url` arg.
+   */
+  url?: string;
+};

package/dist/lib/Steps/Integrations/NextJs.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"NextJs.js","sourceRoot":"","sources":["../../../../lib/Steps/Integrations/NextJs.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AACA,mEAAoE;AAGpE,qDAAoD;AAEpD;;;GAGG;AACH;IAA4B,0BAAe;IACzC,gBAA6B,KAAW;QAAxC,YACE,kBAAM,KAAK,CAAC,SACb;QAF4B,WAAK,GAAL,KAAK,CAAM;;IAExC,CAAC;IAEY,qBAAI,GAAjB,UAAkB,QAAiB;;;;4BACjC,qBAAM,IAAA,+BAAe,EAAC,EAAE,SAAS,EAAE,IAAI,CAAC,KAAK,CAAC,SAAS,EAAE,CAAC,EAAA;;wBAA1D,SAA0D,CAAC;wBAC3D,sBAAO,EAAE,EAAC;;;;KACX;IAEY,gCAAe,GAA5B,UAA6B,QAAiB;;;gBAC5C,kEAAkE;gBAClE,IAAI,IAAI,CAAC,gBAAgB,EAAE;oBACzB,sBAAO,IAAI,CAAC,gBAAgB,EAAC;iBAC9B;gBACD,6DAA6D;gBAC7D,sBAAO,IAAI,CAAC,eAAe,EAAC;;;KAC7B;IACH,aAAC;AAAD,CAAC,AAlBD,CAA4B,iCAAe,GAkB1C;AAlBY,wBAAM","sourcesContent":["import type { Answers } from 'inquirer';\nimport { runNextjsWizard } from '../../../src/nextjs/nextjs-wizard';\n\nimport type { Args } from '../../Constants';\nimport { BaseIntegration } from './BaseIntegration';\n\n/**\n * This class just redirects to the new `nextjs-wizard.ts` flow\n * for anyone calling the wizard without the '-i nextjs' flag.\n */\nexport class NextJs extends BaseIntegration {\n  public constructor(protected _argv: Args) {\n    super(_argv);\n  }\n\n  public async emit(_answers: Answers): Promise<Answers> {\n    await runNextjsWizard({ promoCode: this._argv.promoCode });\n    return {};\n  }\n\n  public async shouldConfigure(_answers: Answers): Promise<Answers> {\n    // eslint-disable-next-line @typescript-eslint/no-misused-promises\n    if (this._shouldConfigure) {\n      return this._shouldConfigure;\n    }\n    // eslint-disable-next-line @typescript-eslint/unbound-method\n    return this.shouldConfigure;\n  }\n}\n"]}

package/dist/lib/Steps/Integrations/SvelteKit.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"SvelteKit.js","sourceRoot":"","sources":["../../../../lib/Steps/Integrations/SvelteKit.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AACA,4EAA6E;AAG7E,qDAAoD;AAEpD;;;GAGG;AACH;IAA+B,6BAAe;IAC5C,mBAA6B,KAAW;QAAxC,YACE,kBAAM,KAAK,CAAC,SACb;QAF4B,WAAK,GAAL,KAAK,CAAM;;IAExC,CAAC;IAEY,wBAAI,GAAjB,UAAkB,QAAiB;;;;4BACjC,qBAAM,IAAA,qCAAkB,EAAC,EAAE,SAAS,EAAE,IAAI,CAAC,KAAK,CAAC,SAAS,EAAE,CAAC,EAAA;;wBAA7D,SAA6D,CAAC;wBAC9D,sBAAO,EAAE,EAAC;;;;KACX;IAEY,mCAAe,GAA5B,UAA6B,QAAiB;;;gBAC5C,kEAAkE;gBAClE,IAAI,IAAI,CAAC,gBAAgB,EAAE;oBACzB,sBAAO,IAAI,CAAC,gBAAgB,EAAC;iBAC9B;gBACD,6DAA6D;gBAC7D,sBAAO,IAAI,CAAC,eAAe,EAAC;;;KAC7B;IACH,gBAAC;AAAD,CAAC,AAlBD,CAA+B,iCAAe,GAkB7C;AAlBY,8BAAS","sourcesContent":["import type { Answers } from 'inquirer';\nimport { runSvelteKitWizard } from '../../../src/sveltekit/sveltekit-wizard';\n\nimport type { Args } from '../../Constants';\nimport { BaseIntegration } from './BaseIntegration';\n\n/**\n * This class just redirects to the new `sveltekit-wizard.ts` flow\n * for anyone calling the wizard without the '-i sveltekit' flag.\n */\nexport class SvelteKit extends BaseIntegration {\n  public constructor(protected _argv: Args) {\n    super(_argv);\n  }\n\n  public async emit(_answers: Answers): Promise<Answers> {\n    await runSvelteKitWizard({ promoCode: this._argv.promoCode });\n    return {};\n  }\n\n  public async shouldConfigure(_answers: Answers): Promise<Answers> {\n    // eslint-disable-next-line @typescript-eslint/no-misused-promises\n    if (this._shouldConfigure) {\n      return this._shouldConfigure;\n    }\n    // eslint-disable-next-line @typescript-eslint/unbound-method\n    return this.shouldConfigure;\n  }\n}\n"]}