@backstage/cli 0.26.6-next.0 → 0.26.6

package/dist/cjs/{index-C9SFHBJ7.cjs.js → index-BWsdQbfr.cjs.js}

@@ -2,14 +2,14 @@
 
 var chalk = require('chalk');
 var inquirer = require('inquirer');
-var tasks = require('./tasks-Dy-6nV0-.cjs.js');
+var tasks = require('./tasks-mGXy8WjR.cjs.js');
 var oauthApp = require('@octokit/oauth-app');
 var fs = require('fs-extra');
 var yaml = require('yaml');
 var cliCommon = require('@backstage/cli-common');
 var path = require('path');
 var differ = require('diff');
-var config = require('./config-Dr_8wy8K.cjs.js');
+var config = require('./config-XS8tRRzZ.cjs.js');
 var catalogModel = require('@backstage/catalog-model');
 var z = require('zod');
 var integration = require('@backstage/integration');
@@ -24,7 +24,7 @@ require('child_process');
 require('@backstage/errors');
 require('@backstage/config-loader');
 require('@backstage/config');
-require('./index-D262VPnW.cjs.js');
+require('./index-CS6xQRSZ.cjs.js');
 require('commander');
 require('semver');
 require('@manypkg/get-packages');
@@ -341,6 +341,7 @@ const getConfig = ({
   }
 });
 const github = async (providerAnswers) => {
+  var _a, _b, _c;
   const answers = await inquirer__default.default.prompt([
     {
       type: "confirm",
@@ -360,12 +361,12 @@ const github = async (providerAnswers) => {
       name: "apiBaseUrl",
       message: "What is your GitHub Enterprise API path?",
       default: "/api/v3",
-      when: ({ hasEnterprise }) => hasEnterprise || providerAnswers?.hasEnterprise
+      when: ({ hasEnterprise }) => hasEnterprise || (providerAnswers == null ? void 0 : providerAnswers.hasEnterprise)
       // TODO(tudi2d): Fetch API using OAuth Token if Auth was set up
     }
   ]);
   const host = new URL(
-    providerAnswers?.enterpriseInstanceUrl ?? answers?.enterpriseInstanceUrl ?? "http://github.com"
+    (_b = (_a = providerAnswers == null ? void 0 : providerAnswers.enterpriseInstanceUrl) != null ? _a : answers == null ? void 0 : answers.enterpriseInstanceUrl) != null ? _b : "http://github.com"
   );
   tasks.Task.log(`
       To create new repositories in GitHub using Software Templates you first need to create a personal access token: ${chalk__default.default.blue(
@@ -400,7 +401,7 @@ const github = async (providerAnswers) => {
     }
   ]);
   const config = getConfig({
-    hasEnterprise: providerAnswers?.hasEnterprise ?? answers.hasEnterprise,
+    hasEnterprise: (_c = providerAnswers == null ? void 0 : providerAnswers.hasEnterprise) != null ? _c : answers.hasEnterprise,
     apiBaseUrl: host.origin + answers.apiBaseUrl,
     host: host.hostname,
     token
@@ -419,8 +420,8 @@ async function integrations(providerInfo) {
     {
       type: "confirm",
       name: "shouldUsePreviousProvider",
-      message: `Do you want to keep using ${providerInfo?.provider} as your provider when setting up Software Templates?`,
-      when: () => providerInfo?.provider && Object.values(Integrations).includes(
+      message: `Do you want to keep using ${providerInfo == null ? void 0 : providerInfo.provider} as your provider when setting up Software Templates?`,
+      when: () => (providerInfo == null ? void 0 : providerInfo.provider) && Object.values(Integrations).includes(
         providerInfo.provider
       )
     },
@@ -438,7 +439,7 @@ async function integrations(providerInfo) {
   }
   switch (answers.integration) {
     case "GitHub" /* GITHUB */: {
-      const providerAnswers = providerInfo?.provider === "GitHub" ? providerInfo.answers : void 0;
+      const providerAnswers = (providerInfo == null ? void 0 : providerInfo.provider) === "GitHub" ? providerInfo.answers : void 0;
       await github(providerAnswers);
       break;
     }
@@ -448,29 +449,62 @@ async function integrations(providerInfo) {
   tasks.Task.log();
 }
 
+var __accessCheck$7 = (obj, member, msg) => {
+  if (!member.has(obj))
+    throw TypeError("Cannot " + msg);
+};
+var __privateGet$6 = (obj, member, getter) => {
+  __accessCheck$7(obj, member, "read from private field");
+  return member.get(obj);
+};
+var __privateAdd$7 = (obj, member, value) => {
+  if (member.has(obj))
+    throw TypeError("Cannot add the same private member more than once");
+  member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
+};
+var _outputs;
 class DefaultAnalysisOutputs {
-  #outputs = /* @__PURE__ */ new Map();
+  constructor() {
+    __privateAdd$7(this, _outputs, /* @__PURE__ */ new Map());
+  }
   produce(output) {
-    this.#outputs.set(output.entity.metadata.name, output);
+    __privateGet$6(this, _outputs).set(output.entity.metadata.name, output);
   }
   list() {
-    return Array.from(this.#outputs).map(([_, output]) => output);
+    return Array.from(__privateGet$6(this, _outputs)).map(([_, output]) => output);
   }
 }
+_outputs = new WeakMap();
 
+var __accessCheck$6 = (obj, member, msg) => {
+  if (!member.has(obj))
+    throw TypeError("Cannot " + msg);
+};
+var __privateGet$5 = (obj, member, getter) => {
+  __accessCheck$6(obj, member, "read from private field");
+  return member.get(obj);
+};
+var __privateAdd$6 = (obj, member, value) => {
+  if (member.has(obj))
+    throw TypeError("Cannot add the same private member more than once");
+  member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
+};
+var _providers, _analyzers;
 class Discovery {
-  #providers = [];
-  #analyzers = [];
+  constructor() {
+    __privateAdd$6(this, _providers, []);
+    __privateAdd$6(this, _analyzers, []);
+  }
   addProvider(provider) {
-    this.#providers.push(provider);
+    __privateGet$5(this, _providers).push(provider);
   }
   addAnalyzer(analyzer) {
-    this.#analyzers.push(analyzer);
+    __privateGet$5(this, _analyzers).push(analyzer);
   }
   async run(url) {
     tasks.Task.log(`Running discovery for ${chalk__default.default.cyan(url)}`);
     const result = [];
-    for (const provider of this.#providers) {
+    for (const provider of __privateGet$5(this, _providers)) {
       const repositories = await provider.discover(url);
       if (repositories && repositories.length) {
         tasks.Task.log(
@@ -481,7 +515,7 @@ class Discovery {
         for (const repository of repositories) {
           await tasks.Task.forItem("Analyzing", repository.name, async () => {
             const output = new DefaultAnalysisOutputs();
-            for (const analyzer of this.#analyzers) {
+            for (const analyzer of __privateGet$5(this, _analyzers)) {
               await analyzer.analyzeRepository({ repository, output });
             }
             output.list().filter((entry) => entry.type === "entity").forEach(({ entity }) => result.push(entity));
@@ -495,6 +529,8 @@ class Discovery {
     };
   }
 }
+_providers = new WeakMap();
+_analyzers = new WeakMap();
 
 class BasicRepositoryAnalyzer {
   name() {
@@ -527,6 +563,7 @@ class PackageJsonAnalyzer {
     return PackageJsonAnalyzer.name;
   }
   async analyzeRepository(options) {
+    var _a, _b;
     const packageJson = await options.repository.file("package.json");
     if (!packageJson) {
       return;
@@ -535,7 +572,7 @@ class PackageJsonAnalyzer {
     if (!content) {
       return;
     }
-    const name = sanitizeName(content?.name) ?? options.repository.name;
+    const name = (_a = sanitizeName(content == null ? void 0 : content.name)) != null ? _a : options.repository.name;
     const entity = {
       apiVersion: "backstage.io/v1alpha1",
       kind: "Component",
@@ -560,7 +597,7 @@ class PackageJsonAnalyzer {
         type: "website"
       };
       decorate.entity.metadata.tags = [
-        ...decorate.entity.metadata.tags ?? [],
+        ...(_b = decorate.entity.metadata.tags) != null ? _b : [],
         "javascript"
       ];
       decorate.entity.metadata.annotations = {
@@ -595,51 +632,103 @@ async function readPackageJson(file) {
   }
 }
 
+var __accessCheck$5 = (obj, member, msg) => {
+  if (!member.has(obj))
+    throw TypeError("Cannot " + msg);
+};
+var __privateGet$4 = (obj, member, getter) => {
+  __accessCheck$5(obj, member, "read from private field");
+  return member.get(obj);
+};
+var __privateAdd$5 = (obj, member, value) => {
+  if (member.has(obj))
+    throw TypeError("Cannot add the same private member more than once");
+  member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
+};
+var __privateSet$4 = (obj, member, value, setter) => {
+  __accessCheck$5(obj, member, "write to private field");
+  member.set(obj, value);
+  return value;
+};
+var _path$1, _content$1;
 class GithubFile {
-  #path;
-  #content;
   constructor(path, content) {
-    this.#path = path;
-    this.#content = content;
+    __privateAdd$5(this, _path$1, void 0);
+    __privateAdd$5(this, _content$1, void 0);
+    __privateSet$4(this, _path$1, path);
+    __privateSet$4(this, _content$1, content);
   }
   get path() {
-    return this.#path;
+    return __privateGet$4(this, _path$1);
   }
   async text() {
-    return this.#content;
+    return __privateGet$4(this, _content$1);
   }
 }
+_path$1 = new WeakMap();
+_content$1 = new WeakMap();
 
+var __accessCheck$4 = (obj, member, msg) => {
+  if (!member.has(obj))
+    throw TypeError("Cannot " + msg);
+};
+var __privateGet$3 = (obj, member, getter) => {
+  __accessCheck$4(obj, member, "read from private field");
+  return member.get(obj);
+};
+var __privateAdd$4 = (obj, member, value) => {
+  if (member.has(obj))
+    throw TypeError("Cannot add the same private member more than once");
+  member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
+};
+var __privateSet$3 = (obj, member, value, setter) => {
+  __accessCheck$4(obj, member, "write to private field");
+  member.set(obj, value);
+  return value;
+};
+var __privateMethod$3 = (obj, member, method) => {
+  __accessCheck$4(obj, member, "access private method");
+  return method;
+};
+var _client, _repo, _org, _getFileContent$1, getFileContent_fn$1;
 class GithubRepository {
-  #client;
-  #repo;
-  #org;
   constructor(client, repo, org) {
-    this.#client = client;
-    this.#repo = repo;
-    this.#org = org;
+    __privateAdd$4(this, _getFileContent$1);
+    __privateAdd$4(this, _client, void 0);
+    __privateAdd$4(this, _repo, void 0);
+    __privateAdd$4(this, _org, void 0);
+    __privateSet$3(this, _client, client);
+    __privateSet$3(this, _repo, repo);
+    __privateSet$3(this, _org, org);
   }
   get url() {
-    return this.#repo.url;
+    return __privateGet$3(this, _repo).url;
   }
   get name() {
-    return this.#repo.name;
+    return __privateGet$3(this, _repo).name;
   }
   get owner() {
-    return this.#org;
+    return __privateGet$3(this, _org);
   }
   get description() {
-    return this.#repo.description ?? void 0;
+    var _a;
+    return (_a = __privateGet$3(this, _repo).description) != null ? _a : void 0;
   }
   async file(filename) {
-    const content = await this.#getFileContent(filename);
+    var _a;
+    const content = await __privateMethod$3(this, _getFileContent$1, getFileContent_fn$1).call(this, filename);
     if (!content || content.isBinary || !content.text) {
       return void 0;
     }
-    return new GithubFile(filename, content.text ?? "");
+    return new GithubFile(filename, (_a = content.text) != null ? _a : "");
   }
-  async #getFileContent(filename) {
-    const query = `query RepoFiles($owner: String!, $name: String!, $expr: String!) {
+}
+_client = new WeakMap();
+_repo = new WeakMap();
+_org = new WeakMap();
+_getFileContent$1 = new WeakSet();
+getFileContent_fn$1 = async function(filename) {
+  const query = `query RepoFiles($owner: String!, $name: String!, $expr: String!) {
       repository(owner: $owner, name: $name) {
         object(expression: $expr) {
           ...on Blob {
@@ -649,37 +738,58 @@ class GithubRepository {
         }
       }
     }`;
-    const response = await this.#client(
-      query,
-      {
-        name: this.#repo.name,
-        owner: this.#org,
-        expr: `HEAD:${filename}`
-      }
-    );
-    return response.repository.object;
-  }
-}
+  const response = await __privateGet$3(this, _client).call(this, query, {
+    name: __privateGet$3(this, _repo).name,
+    owner: __privateGet$3(this, _org),
+    expr: `HEAD:${filename}`
+  });
+  return response.repository.object;
+};
 
-class GithubDiscoveryProvider {
-  #envToken;
-  #scmIntegrations;
-  #credentialsProvider;
+var __accessCheck$3 = (obj, member, msg) => {
+  if (!member.has(obj))
+    throw TypeError("Cannot " + msg);
+};
+var __privateGet$2 = (obj, member, getter) => {
+  __accessCheck$3(obj, member, "read from private field");
+  return member.get(obj);
+};
+var __privateAdd$3 = (obj, member, value) => {
+  if (member.has(obj))
+    throw TypeError("Cannot add the same private member more than once");
+  member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
+};
+var __privateSet$2 = (obj, member, value, setter) => {
+  __accessCheck$3(obj, member, "write to private field");
+  member.set(obj, value);
+  return value;
+};
+var __privateMethod$2 = (obj, member, method) => {
+  __accessCheck$3(obj, member, "access private method");
+  return method;
+};
+var _envToken$1, _scmIntegrations$1, _credentialsProvider$1, _getRequestHeaders$1, getRequestHeaders_fn$1, _getOrganizationRepositories, getOrganizationRepositories_fn;
+const _GithubDiscoveryProvider = class _GithubDiscoveryProvider {
+  constructor(envToken, integrations, credentialsProvider) {
+    __privateAdd$3(this, _getRequestHeaders$1);
+    __privateAdd$3(this, _getOrganizationRepositories);
+    __privateAdd$3(this, _envToken$1, void 0);
+    __privateAdd$3(this, _scmIntegrations$1, void 0);
+    __privateAdd$3(this, _credentialsProvider$1, void 0);
+    __privateSet$2(this, _envToken$1, envToken);
+    __privateSet$2(this, _scmIntegrations$1, integrations);
+    __privateSet$2(this, _credentialsProvider$1, credentialsProvider);
+  }
   static fromConfig(config) {
     const envToken = process.env.GITHUB_TOKEN || void 0;
     const scmIntegrations = integration.ScmIntegrations.fromConfig(config);
     const credentialsProvider = integration.DefaultGithubCredentialsProvider.fromIntegrations(scmIntegrations);
-    return new GithubDiscoveryProvider(
+    return new _GithubDiscoveryProvider(
       envToken,
       scmIntegrations,
       credentialsProvider
     );
   }
-  constructor(envToken, integrations, credentialsProvider) {
-    this.#envToken = envToken;
-    this.#scmIntegrations = integrations;
-    this.#credentialsProvider = credentialsProvider;
-  }
   name() {
     return "GitHub";
   }
@@ -687,7 +797,7 @@ class GithubDiscoveryProvider {
     if (!url.startsWith("https://github.com/")) {
       return false;
     }
-    const scmIntegration = this.#scmIntegrations.github.byUrl(url);
+    const scmIntegration = __privateGet$2(this, _scmIntegrations$1).github.byUrl(url);
     if (!scmIntegration) {
       throw new Error(`No GitHub integration found for ${url}`);
     }
@@ -696,32 +806,36 @@ class GithubDiscoveryProvider {
     const org = organization || name;
     const client = graphql.graphql.defaults({
       baseUrl: scmIntegration.config.apiBaseUrl,
-      headers: await this.#getRequestHeaders(url)
+      headers: await __privateMethod$2(this, _getRequestHeaders$1, getRequestHeaders_fn$1).call(this, url)
     });
-    const { repositories } = await this.#getOrganizationRepositories(
-      client,
-      org
-    );
+    const { repositories } = await __privateMethod$2(this, _getOrganizationRepositories, getOrganizationRepositories_fn).call(this, client, org);
     return repositories.filter((repo) => repo.url.startsWith(url)).map((repo) => new GithubRepository(client, repo, org));
   }
-  async #getRequestHeaders(url) {
-    const credentials = await this.#credentialsProvider.getCredentials({
-      url
-    });
-    if (credentials.headers) {
-      return credentials.headers;
-    } else if (credentials.token) {
-      return { authorization: `token ${credentials.token}` };
-    }
-    if (this.#envToken) {
-      return { authorization: `token ${this.#envToken}` };
-    }
-    throw new Error(
-      "No token available for GitHub, please configure your integrations or set a GITHUB_TOKEN env variable"
-    );
+};
+_envToken$1 = new WeakMap();
+_scmIntegrations$1 = new WeakMap();
+_credentialsProvider$1 = new WeakMap();
+_getRequestHeaders$1 = new WeakSet();
+getRequestHeaders_fn$1 = async function(url) {
+  const credentials = await __privateGet$2(this, _credentialsProvider$1).getCredentials({
+    url
+  });
+  if (credentials.headers) {
+    return credentials.headers;
+  } else if (credentials.token) {
+    return { authorization: `token ${credentials.token}` };
   }
-  async #getOrganizationRepositories(client, org) {
-    const query = `query repositories($org: String!, $cursor: String) {
+  if (__privateGet$2(this, _envToken$1)) {
+    return { authorization: `token ${__privateGet$2(this, _envToken$1)}` };
+  }
+  throw new Error(
+    "No token available for GitHub, please configure your integrations or set a GITHUB_TOKEN env variable"
+  );
+};
+_getOrganizationRepositories = new WeakSet();
+getOrganizationRepositories_fn = async function(client, org) {
+  var _a, _b;
+  const query = `query repositories($org: String!, $cursor: String) {
       repositoryOwner(login: $org) {
         login
         repositories(first: 50, after: $cursor) {
@@ -739,52 +853,89 @@ class GithubDiscoveryProvider {
         }
       }
     }`;
-    const result = [];
-    let cursor = void 0;
-    let hasNextPage = true;
-    while (hasNextPage) {
-      const response = await client(query, {
-        org,
-        cursor
-      });
-      const { repositories: connection } = response.repositoryOwner ?? {};
-      if (!connection) {
-        throw new Error(`Found no repositories for ${org}`);
-      }
-      for (const repository of connection.nodes ?? []) {
-        if (repository && !repository.isArchived && !repository.isFork) {
-          result.push(repository);
-        }
+  const result = [];
+  let cursor = void 0;
+  let hasNextPage = true;
+  while (hasNextPage) {
+    const response = await client(query, {
+      org,
+      cursor
+    });
+    const { repositories: connection } = (_a = response.repositoryOwner) != null ? _a : {};
+    if (!connection) {
+      throw new Error(`Found no repositories for ${org}`);
+    }
+    for (const repository of (_b = connection.nodes) != null ? _b : []) {
+      if (repository && !repository.isArchived && !repository.isFork) {
+        result.push(repository);
       }
-      cursor = connection.pageInfo.endCursor;
-      hasNextPage = connection.pageInfo.hasNextPage;
     }
-    return {
-      repositories: result
-    };
+    cursor = connection.pageInfo.endCursor;
+    hasNextPage = connection.pageInfo.hasNextPage;
   }
-}
+  return {
+    repositories: result
+  };
+};
+let GithubDiscoveryProvider = _GithubDiscoveryProvider;
 
+var __accessCheck$2 = (obj, member, msg) => {
+  if (!member.has(obj))
+    throw TypeError("Cannot " + msg);
+};
+var __privateGet$1 = (obj, member, getter) => {
+  __accessCheck$2(obj, member, "read from private field");
+  return member.get(obj);
+};
+var __privateAdd$2 = (obj, member, value) => {
+  if (member.has(obj))
+    throw TypeError("Cannot add the same private member more than once");
+  member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
+};
+var __privateSet$1 = (obj, member, value, setter) => {
+  __accessCheck$2(obj, member, "write to private field");
+  member.set(obj, value);
+  return value;
+};
+var _path, _content;
 class GitlabFile {
-  #path;
-  #content;
   constructor(path, content) {
-    this.#path = path;
-    this.#content = content;
+    __privateAdd$2(this, _path, void 0);
+    __privateAdd$2(this, _content, void 0);
+    __privateSet$1(this, _path, path);
+    __privateSet$1(this, _content, content);
   }
   get path() {
-    return this.#path;
+    return __privateGet$1(this, _path);
   }
   async text() {
-    return this.#content;
+    return __privateGet$1(this, _content);
   }
 }
+_path = new WeakMap();
+_content = new WeakMap();
 
+var __accessCheck$1 = (obj, member, msg) => {
+  if (!member.has(obj))
+    throw TypeError("Cannot " + msg);
+};
+var __privateAdd$1 = (obj, member, value) => {
+  if (member.has(obj))
+    throw TypeError("Cannot add the same private member more than once");
+  member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
+};
+var __privateMethod$1 = (obj, member, method) => {
+  __accessCheck$1(obj, member, "access private method");
+  return method;
+};
+var _getFileContent, getFileContent_fn, _getMainBranch, getMainBranch_fn;
 class GitlabProject {
   constructor(project, apiBaseUrl, headers) {
     this.project = project;
     this.apiBaseUrl = apiBaseUrl;
     this.headers = headers;
+    __privateAdd$1(this, _getFileContent);
+    __privateAdd$1(this, _getMainBranch);
   }
   get url() {
     return this.project.web_url;
@@ -799,58 +950,85 @@ class GitlabProject {
     return this.project.description;
   }
   async file(filename) {
-    const mainBranch = await this.#getMainBranch();
-    const content = await this.#getFileContent(filename, mainBranch);
+    const mainBranch = await __privateMethod$1(this, _getMainBranch, getMainBranch_fn).call(this);
+    const content = await __privateMethod$1(this, _getFileContent, getFileContent_fn).call(this, filename, mainBranch);
     return new GitlabFile(filename, content);
   }
-  async #getFileContent(path, mainBranch) {
-    const response = await fetch__default.default(
-      `${this.apiBaseUrl}/projects/${this.project.id}/repository/files/${path}?ref=${mainBranch}`,
-      { headers: this.headers }
-    );
-    const { content } = await response.json();
-    return Buffer.from(content, "base64").toString("ascii");
-  }
-  async #getMainBranch() {
-    const response = await fetch__default.default(
-      `${this.apiBaseUrl}/projects/${this.project.id}/repository/branches`,
-      { headers: this.headers }
-    );
-    const branches = await response.json();
-    return branches.find((branch) => branch.default)?.name ?? "main";
-  }
 }
+_getFileContent = new WeakSet();
+getFileContent_fn = async function(path, mainBranch) {
+  const response = await fetch__default.default(
+    `${this.apiBaseUrl}/projects/${this.project.id}/repository/files/${path}?ref=${mainBranch}`,
+    { headers: this.headers }
+  );
+  const { content } = await response.json();
+  return Buffer.from(content, "base64").toString("ascii");
+};
+_getMainBranch = new WeakSet();
+getMainBranch_fn = async function() {
+  var _a, _b;
+  const response = await fetch__default.default(
+    `${this.apiBaseUrl}/projects/${this.project.id}/repository/branches`,
+    { headers: this.headers }
+  );
+  const branches = await response.json();
+  return (_b = (_a = branches.find((branch) => branch.default)) == null ? void 0 : _a.name) != null ? _b : "main";
+};
 
-class GitlabDiscoveryProvider {
-  #envToken;
-  #scmIntegrations;
-  #credentialsProvider;
+var __accessCheck = (obj, member, msg) => {
+  if (!member.has(obj))
+    throw TypeError("Cannot " + msg);
+};
+var __privateGet = (obj, member, getter) => {
+  __accessCheck(obj, member, "read from private field");
+  return member.get(obj);
+};
+var __privateAdd = (obj, member, value) => {
+  if (member.has(obj))
+    throw TypeError("Cannot add the same private member more than once");
+  member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
+};
+var __privateSet = (obj, member, value, setter) => {
+  __accessCheck(obj, member, "write to private field");
+  member.set(obj, value);
+  return value;
+};
+var __privateMethod = (obj, member, method) => {
+  __accessCheck(obj, member, "access private method");
+  return method;
+};
+var _envToken, _scmIntegrations, _credentialsProvider, _getRequestHeaders, getRequestHeaders_fn;
+const _GitlabDiscoveryProvider = class _GitlabDiscoveryProvider {
+  constructor(envToken, integrations, credentialsProvider) {
+    __privateAdd(this, _getRequestHeaders);
+    __privateAdd(this, _envToken, void 0);
+    __privateAdd(this, _scmIntegrations, void 0);
+    __privateAdd(this, _credentialsProvider, void 0);
+    __privateSet(this, _envToken, envToken);
+    __privateSet(this, _scmIntegrations, integrations);
+    __privateSet(this, _credentialsProvider, credentialsProvider);
+  }
   static fromConfig(config) {
     const envToken = process.env.GITLAB_TOKEN || void 0;
     const scmIntegrations = integration.ScmIntegrations.fromConfig(config);
     const credentialsProvider = integration.DefaultGitlabCredentialsProvider.fromIntegrations(scmIntegrations);
-    return new GitlabDiscoveryProvider(
+    return new _GitlabDiscoveryProvider(
       envToken,
       scmIntegrations,
       credentialsProvider
     );
   }
-  constructor(envToken, integrations, credentialsProvider) {
-    this.#envToken = envToken;
-    this.#scmIntegrations = integrations;
-    this.#credentialsProvider = credentialsProvider;
-  }
   name() {
     return "GitLab";
   }
   async discover(url) {
     const { origin, pathname } = new URL(url);
     const [, user] = pathname.split("/");
-    const scmIntegration = this.#scmIntegrations.gitlab.byUrl(origin);
+    const scmIntegration = __privateGet(this, _scmIntegrations).gitlab.byUrl(origin);
     if (!scmIntegration) {
       throw new Error(`No GitLab integration found for ${origin}`);
     }
-    const headers = await this.#getRequestHeaders(origin);
+    const headers = await __privateMethod(this, _getRequestHeaders, getRequestHeaders_fn).call(this, origin);
     const response = await fetch__default.default(
       `${scmIntegration.config.apiBaseUrl}/users/${user}/projects`,
       { headers }
@@ -863,23 +1041,28 @@ class GitlabDiscoveryProvider {
       (project) => new GitlabProject(project, scmIntegration.config.apiBaseUrl, headers)
     );
   }
-  async #getRequestHeaders(url) {
-    const credentials = await this.#credentialsProvider.getCredentials({
-      url
-    });
-    if (credentials.headers) {
-      return credentials.headers;
-    } else if (credentials.token) {
-      return { authorization: `Bearer ${credentials.token}` };
-    }
-    if (this.#envToken) {
-      return { authorization: `Bearer ${this.#envToken}` };
-    }
-    throw new Error(
-      "No token available for GitLab, please set a GITLAB_TOKEN env variable"
-    );
+};
+_envToken = new WeakMap();
+_scmIntegrations = new WeakMap();
+_credentialsProvider = new WeakMap();
+_getRequestHeaders = new WeakSet();
+getRequestHeaders_fn = async function(url) {
+  const credentials = await __privateGet(this, _credentialsProvider).getCredentials({
+    url
+  });
+  if (credentials.headers) {
+    return credentials.headers;
+  } else if (credentials.token) {
+    return { authorization: `Bearer ${credentials.token}` };
   }
-}
+  if (__privateGet(this, _envToken)) {
+    return { authorization: `Bearer ${__privateGet(this, _envToken)}` };
+  }
+  throw new Error(
+    "No token available for GitLab, please set a GITLAB_TOKEN env variable"
+  );
+};
+let GitlabDiscoveryProvider = _GitlabDiscoveryProvider;
 
 async function discover(providerInfo) {
   tasks.Task.log(`
@@ -905,7 +1088,7 @@ async function discover(providerInfo) {
       name: "provider",
       message: "Please select which SCM provider you want to use:",
       choices: ["GitHub", "GitLab"],
-      default: providerInfo?.provider,
+      default: providerInfo == null ? void 0 : providerInfo.provider,
       when: ({ shouldContinue }) => shouldContinue
     },
     {
@@ -1024,4 +1207,4 @@ async function command() {
 }
 
 exports.command = command;
-//# sourceMappingURL=index-C9SFHBJ7.cjs.js.map
+//# sourceMappingURL=index-BWsdQbfr.cjs.js.map