@capraconsulting/cals-cli 3.11.4 → 3.12.1

package/lib/config.d.ts

@@ -1,4 +1,4 @@
-import https from "https";
+import https from "node:https";
 export declare class Config {
     cwd: string;
     configFile: string;

package/lib/definition/definition.d.ts

@@ -1,5 +1,5 @@
 import schema from "../definition-schema.json";
-import { Definition, GetReposResponse } from "./types";
+import type { Definition, GetReposResponse } from "./types";
 export { schema };
 export declare function getRepoId(orgName: string, repoName: string): string;
 export declare class DefinitionFile {

package/lib/definition/types.d.ts

@@ -1,4 +1,4 @@
-import { Permission } from "../github/types";
+import type { Permission } from "../github/types";
 export interface Definition {
     snyk?: {
         accountId: string;

package/lib/github/changeset/changeset.d.ts

@@ -1,7 +1,7 @@
-import { Definition } from "../../definition/types";
-import { GitHubService } from "../service";
-import { OrgsGetResponse } from "../types";
-import { ChangeSetItem } from "./types";
+import type { Definition } from "../../definition/types";
+import type { GitHubService } from "../service";
+import type { OrgsGetResponse } from "../types";
+import type { ChangeSetItem } from "./types";
 /**
  * Generate change set items for projects.
  */

package/lib/github/changeset/execute.d.ts

@@ -1,6 +1,6 @@
-import { Reporter } from "../../cli/reporter";
-import { GitHubService } from "../service";
-import { ChangeSetItem, RepoCreateItem } from "./types";
+import type { Reporter } from "../../cli/reporter";
+import type { GitHubService } from "../service";
+import type { ChangeSetItem, RepoCreateItem } from "./types";
 type NotImplementedChangeSetItem = RepoCreateItem;
 export declare function isNotImplementedChangeSetItem(changeItem: ChangeSetItem): changeItem is NotImplementedChangeSetItem;
 /**

package/lib/github/changeset/types.d.ts

@@ -1,4 +1,4 @@
-import { Permission } from "../types";
+import type { Permission } from "../types";
 export interface RepoCreateItem {
     type: "repo-create";
     org: string;

package/lib/github/index.d.ts

@@ -1,3 +1,3 @@
-export { createGitHubService, GitHubService } from "./service";
 export type { SearchedPullRequestListItem } from "./service";
+export { createGitHubService, GitHubService } from "./service";
 export type { RenovateDependencyDashboardIssue, VulnerabilityAlert, } from "./types";

package/lib/github/service.d.ts

@@ -1,8 +1,8 @@
 import { Octokit } from "@octokit/rest";
-import { CacheProvider } from "../cache";
-import { Config } from "../config";
-import { GitHubTokenProvider } from "./token";
-import { OrgMemberOrInvited, OrgsGetResponse, OrgsListMembersResponseItem, OrgsListPendingInvitationsResponseItem, RenovateDependencyDashboardIssue, Repo, ReposGetResponse, ReposListHooksResponseItem, ReposListTeamsResponseItem, TeamMemberOrInvited, TeamsListMembersResponseItem, TeamsListPendingInvitationsResponseItem, TeamsListResponseItem, VulnerabilityAlert } from "./types";
+import type { CacheProvider } from "../cache";
+import type { Config } from "../config";
+import { type GitHubTokenProvider } from "./token";
+import type { OrgMemberOrInvited, OrgsGetResponse, OrgsListMembersResponseItem, OrgsListPendingInvitationsResponseItem, RenovateDependencyDashboardIssue, Repo, ReposGetResponse, ReposListHooksResponseItem, ReposListTeamsResponseItem, TeamMemberOrInvited, TeamsListMembersResponseItem, TeamsListPendingInvitationsResponseItem, TeamsListResponseItem, VulnerabilityAlert } from "./types";
 interface SearchedPullRequestListQueryResult {
     search: {
         pageInfo: {

package/lib/github/types.d.ts

@@ -1,4 +1,4 @@
-import { Endpoints } from "@octokit/types";
+import type { Endpoints } from "@octokit/types";
 export type OrgsGetResponse = Endpoints["GET /orgs/{org}"]["response"]["data"];
 export type OrgsListMembersResponseItem = Exclude<Endpoints["GET /orgs/{org}/members"]["response"]["data"][0], null>;
 export type OrgsListPendingInvitationsResponseItem = Endpoints["GET /orgs/{org}/invitations"]["response"]["data"][0];

package/lib/github/util.d.ts

@@ -1,4 +1,4 @@
-import { Repo } from "./types";
+import type { Repo } from "./types";
 export declare function getGroup(repo: Repo): string | null;
 export declare function getGroupedRepos(repos: Repo[]): {
     name: string;

package/lib/index.es.js

@@ -1,27 +1,27 @@
 import fs from 'node:fs';
-import path from 'path';
-import chalk from 'chalk';
-import readline from 'readline';
+import path from 'node:path';
 import process$1 from 'node:process';
-import 'util';
+import readline from 'node:readline';
+import chalk from 'chalk';
+import 'node:util';
+import https from 'node:https';
+import os from 'node:os';
 import cachedir from 'cachedir';
-import https from 'https';
-import os from 'os';
 import AJV from 'ajv';
 import yaml from 'js-yaml';
+import { Buffer } from 'node:buffer';
+import { performance } from 'node:perf_hooks';
 import { Octokit } from '@octokit/rest';
 import fetch from 'node-fetch';
 import pLimit from 'p-limit';
-import keytar from 'keytar';
 import * as process from 'process';
-import { performance } from 'perf_hooks';
-import { Buffer } from 'node:buffer';
-import { strict } from 'assert';
+import keytar from 'keytar';
+import { strict } from 'node:assert';
+import { Transform } from 'node:stream';
 import { execa } from 'execa';
 import { read } from 'read';
-import { Transform } from 'stream';
 
-var version = "3.11.4";
+var version = "3.12.1";
 
 class CacheProvider {
     constructor(config) {
@@ -60,7 +60,7 @@ class CacheProvider {
         const cacheItem = this.mustValidate
             ? undefined
             : this.retrieveJson(cachekey);
-        const expire = new Date(new Date().getTime() - cachetime * 1000).getTime();
+        const expire = new Date(Date.now() - cachetime * 1000).getTime();
         if (cacheItem !== undefined && cacheItem.cacheTime > expire) {
             return cacheItem.data;
         }
@@ -131,7 +131,6 @@ class Config {
             return {};
         }
         try {
-            // eslint-disable-next-line @typescript-eslint/no-unsafe-return
             return JSON.parse(fs.readFileSync(this.configFile, "utf-8"));
         }
         catch (e) {
@@ -159,6 +158,10 @@ class Config {
     }
 }
 
+function uniq(array) {
+    return Array.from(new Set(array));
+}
+
 var type = "object";
 var properties = {
 	snyk: {
@@ -453,10 +456,6 @@ var schema = {
 	$schema: $schema
 };
 
-function uniq(array) {
-    return Array.from(new Set(array));
-}
-
 function getTeamId(org, teamName) {
     return `${org}/${teamName}`;
 }
@@ -490,8 +489,7 @@ function requireValidDefinition(definition) {
     }, []);
     // Verify team members exists as users.
     definition.github.teams
-        .map((it) => it.teams)
-        .flat()
+        .flatMap((it) => it.teams)
         .forEach((team) => {
         team.members.forEach((login) => {
             if (!loginList.includes(login)) {
@@ -527,9 +525,7 @@ function requireValidDefinition(definition) {
     });
     // Verify no duplicates in repos.
     definition.projects
-        .flatMap((project) => project.github
-        .map((org) => (org.repos || []).map((repo) => getRepoId(org.organization, repo.name)))
-        .flat())
+        .flatMap((project) => project.github.flatMap((org) => (org.repos || []).map((repo) => getRepoId(org.organization, repo.name))))
         .reduce((acc, repoName) => {
         if (acc.includes(repoName)) {
             throw new Error(`Duplicate repo: ${repoName}`);
@@ -557,20 +553,18 @@ class DefinitionFile {
 function parseDefinition(value) {
     const result = checkAgainstSchema(yaml.load(value));
     if ("error" in result) {
-        throw new Error("Definition content invalid: " + result.error);
+        throw new Error(`Definition content invalid: ${result.error}`);
     }
     requireValidDefinition(result.definition);
     return result.definition;
 }
 function getRepos(definition) {
-    return definition.projects.flatMap((project) => project.github
-        .map((org) => (org.repos || []).map((repo) => ({
+    return definition.projects.flatMap((project) => project.github.flatMap((org) => (org.repos || []).map((repo) => ({
         id: getRepoId(org.organization, repo.name),
         orgName: org.organization,
         project,
         repo,
-    })))
-        .flat());
+    }))));
 }
 function getGitHubOrgs(definition) {
     const githubOrganizations = definition.projects.flatMap((project) => project.github.map((it) => it.organization));
@@ -620,13 +614,10 @@ async function undefinedForNotFound(value) {
         return await value;
     }
     catch (e) {
-        // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
         if (e.name === "HttpError" && e.status === 404) {
             return undefined;
         }
-        else {
-            throw e;
-        }
+        throw e;
     }
 }
 
@@ -645,17 +636,14 @@ class GitHubService {
         // can maximize concurrency all other places.
         this.semaphore = pLimit(6);
         this.octokit.hook.wrap("request", async (request, options) => {
-            /* eslint-disable @typescript-eslint/no-unsafe-member-access */
             this._requestCount++;
             if (options.method !== "GET") {
                 return this.semaphore(() => request(options));
             }
             // Try to cache ETag for GET requests to save on rate limiting.
             // Hits on ETag does not count towards rate limiting.
-            // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
             const rest = {
                 ...options,
-                // eslint-disable-next-line @typescript-eslint/no-explicit-any
             };
             delete rest.method;
             delete rest.baseUrl;
@@ -706,7 +694,6 @@ class GitHubService {
                 });
             }
             return response;
-            /* eslint-enable @typescript-eslint/no-unsafe-member-access */
         });
     }
     _requestCount = 0;
@@ -746,11 +733,11 @@ class GitHubService {
             throw new Error(`Response from GitHub not OK (${response.status}): ${await response.text()}`);
         }
         const json = (await response.json());
-        if (!!json.errors) {
+        if (json.errors) {
             throw new Error(`Error from GitHub GraphQL API: ${JSON.stringify(json.errors)}`);
         }
         if (json.data == null) {
-            throw new Error(`No data received from GitHub GraphQL API (unknown reason)`);
+            throw new Error("No data received from GitHub GraphQL API (unknown reason)");
         }
         return json.data;
     }
@@ -983,7 +970,6 @@ class GitHubService {
             return true;
         }
         catch (e) {
-            // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
             if (e.status === 404) {
                 return false;
             }
@@ -1257,8 +1243,7 @@ function getGitHubRepo(snykProject) {
             name: match[2],
         };
     }
-    else if (snykProject.origin === "cli" &&
-        snykProject.remoteRepoUrl != null) {
+    if (snykProject.origin === "cli" && snykProject.remoteRepoUrl != null) {
         // The remoteRepoUrl can be overridden when using the CLI, so don't
         // fail if we cannot extract the value.
         const match = /github.com\/([^/]+)\/(.+)\.git$/.exec(snykProject.remoteRepoUrl);
@@ -1270,9 +1255,7 @@ function getGitHubRepo(snykProject) {
             name: match[2],
         };
     }
-    else {
-        return undefined;
-    }
+    return undefined;
 }
 function getGitHubRepoId(repo) {
     return repo ? `${repo.owner}/${repo.name}` : undefined;
@@ -1424,12 +1407,11 @@ class TestExecutor {
             await body(this);
         }
         catch (error) {
-            // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
             console.error(error.stack || error.message || error);
             process$1.exitCode = 1;
         }
         finally {
-            console.log(`Reached finally block`);
+            console.log("Reached finally block");
             this.usingWithCleanupTasks = false;
             if (this.cleanupTask == null) {
                 this.cleanupTask = this.runTasks();
@@ -1448,8 +1430,8 @@ function createTestExecutor() {
  * Gives a value formatted as "yyyymmdd-xxxxxx", e.g. "20200523-3f2c87".
  */
 function generateRunId() {
-    const low = parseInt("100000", 16);
-    const high = parseInt("ffffff", 16);
+    const low = 0x100000;
+    const high = 0xffffff;
     const range = high - low + 1;
     const now = new Date();
     return [
@@ -1610,7 +1592,7 @@ class OutputPrefixTransform extends Transform {
                 if (result.endsWith("\n\u001B[0m")) {
                     result = result.slice(0, -5) + result.slice(-4);
                 }
-                result = prefix + result.replace(/\n/g, `\n${prefix}`) + "\n";
+                result = `${prefix + result.replace(/\n/g, `\n${prefix}`)}\n`;
                 callback(null, result);
             },
         });
@@ -1739,12 +1721,11 @@ async function startContainer({ executor, network, imageId, alias, env, dockerAr
     executor.registerCleanupTask(async () => {
         console.log(`Stopping container ${containerName}`);
         const r = execa("docker", ["stop", containerName]);
-        pipeToConsole(r, (alias ?? containerName) + " (stop)");
+        pipeToConsole(r, `${alias ?? containerName} (stop)`);
         try {
             await r;
         }
         catch (e) {
-            // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access, @typescript-eslint/no-unsafe-call
             if (!(e.stderr || "").includes("No such container")) {
                 throw e;
             }

package/lib/index.es.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.es.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}
+{"version":3,"file":"index.es.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/lib/index.js

@@ -1,27 +1,27 @@
 import fs from 'node:fs';
-import path from 'path';
-import chalk from 'chalk';
-import readline from 'readline';
+import path from 'node:path';
 import process$1 from 'node:process';
-import 'util';
+import readline from 'node:readline';
+import chalk from 'chalk';
+import 'node:util';
+import https from 'node:https';
+import os from 'node:os';
 import cachedir from 'cachedir';
-import https from 'https';
-import os from 'os';
 import AJV from 'ajv';
 import yaml from 'js-yaml';
+import { Buffer } from 'node:buffer';
+import { performance } from 'node:perf_hooks';
 import { Octokit } from '@octokit/rest';
 import fetch from 'node-fetch';
 import pLimit from 'p-limit';
-import keytar from 'keytar';
 import * as process from 'process';
-import { performance } from 'perf_hooks';
-import { Buffer } from 'node:buffer';
-import { strict } from 'assert';
+import keytar from 'keytar';
+import { strict } from 'node:assert';
+import { Transform } from 'node:stream';
 import { execa } from 'execa';
 import { read } from 'read';
-import { Transform } from 'stream';
 
-var version = "3.11.4";
+var version = "3.12.1";
 
 class CacheProvider {
     constructor(config) {
@@ -60,7 +60,7 @@ class CacheProvider {
         const cacheItem = this.mustValidate
             ? undefined
             : this.retrieveJson(cachekey);
-        const expire = new Date(new Date().getTime() - cachetime * 1000).getTime();
+        const expire = new Date(Date.now() - cachetime * 1000).getTime();
         if (cacheItem !== undefined && cacheItem.cacheTime > expire) {
             return cacheItem.data;
         }
@@ -131,7 +131,6 @@ class Config {
             return {};
         }
         try {
-            // eslint-disable-next-line @typescript-eslint/no-unsafe-return
             return JSON.parse(fs.readFileSync(this.configFile, "utf-8"));
         }
         catch (e) {
@@ -159,6 +158,10 @@ class Config {
     }
 }
 
+function uniq(array) {
+    return Array.from(new Set(array));
+}
+
 var type = "object";
 var properties = {
 	snyk: {
@@ -453,10 +456,6 @@ var schema = {
 	$schema: $schema
 };
 
-function uniq(array) {
-    return Array.from(new Set(array));
-}
-
 function getTeamId(org, teamName) {
     return `${org}/${teamName}`;
 }
@@ -490,8 +489,7 @@ function requireValidDefinition(definition) {
     }, []);
     // Verify team members exists as users.
     definition.github.teams
-        .map((it) => it.teams)
-        .flat()
+        .flatMap((it) => it.teams)
         .forEach((team) => {
         team.members.forEach((login) => {
             if (!loginList.includes(login)) {
@@ -527,9 +525,7 @@ function requireValidDefinition(definition) {
     });
     // Verify no duplicates in repos.
     definition.projects
-        .flatMap((project) => project.github
-        .map((org) => (org.repos || []).map((repo) => getRepoId(org.organization, repo.name)))
-        .flat())
+        .flatMap((project) => project.github.flatMap((org) => (org.repos || []).map((repo) => getRepoId(org.organization, repo.name))))
         .reduce((acc, repoName) => {
         if (acc.includes(repoName)) {
             throw new Error(`Duplicate repo: ${repoName}`);
@@ -557,20 +553,18 @@ class DefinitionFile {
 function parseDefinition(value) {
     const result = checkAgainstSchema(yaml.load(value));
     if ("error" in result) {
-        throw new Error("Definition content invalid: " + result.error);
+        throw new Error(`Definition content invalid: ${result.error}`);
     }
     requireValidDefinition(result.definition);
     return result.definition;
 }
 function getRepos(definition) {
-    return definition.projects.flatMap((project) => project.github
-        .map((org) => (org.repos || []).map((repo) => ({
+    return definition.projects.flatMap((project) => project.github.flatMap((org) => (org.repos || []).map((repo) => ({
         id: getRepoId(org.organization, repo.name),
         orgName: org.organization,
         project,
         repo,
-    })))
-        .flat());
+    }))));
 }
 function getGitHubOrgs(definition) {
     const githubOrganizations = definition.projects.flatMap((project) => project.github.map((it) => it.organization));
@@ -620,13 +614,10 @@ async function undefinedForNotFound(value) {
         return await value;
     }
     catch (e) {
-        // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
         if (e.name === "HttpError" && e.status === 404) {
             return undefined;
         }
-        else {
-            throw e;
-        }
+        throw e;
     }
 }
 
@@ -645,17 +636,14 @@ class GitHubService {
         // can maximize concurrency all other places.
         this.semaphore = pLimit(6);
         this.octokit.hook.wrap("request", async (request, options) => {
-            /* eslint-disable @typescript-eslint/no-unsafe-member-access */
             this._requestCount++;
             if (options.method !== "GET") {
                 return this.semaphore(() => request(options));
             }
             // Try to cache ETag for GET requests to save on rate limiting.
             // Hits on ETag does not count towards rate limiting.
-            // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
             const rest = {
                 ...options,
-                // eslint-disable-next-line @typescript-eslint/no-explicit-any
             };
             delete rest.method;
             delete rest.baseUrl;
@@ -706,7 +694,6 @@ class GitHubService {
                 });
             }
             return response;
-            /* eslint-enable @typescript-eslint/no-unsafe-member-access */
         });
     }
     _requestCount = 0;
@@ -746,11 +733,11 @@ class GitHubService {
             throw new Error(`Response from GitHub not OK (${response.status}): ${await response.text()}`);
         }
         const json = (await response.json());
-        if (!!json.errors) {
+        if (json.errors) {
             throw new Error(`Error from GitHub GraphQL API: ${JSON.stringify(json.errors)}`);
         }
         if (json.data == null) {
-            throw new Error(`No data received from GitHub GraphQL API (unknown reason)`);
+            throw new Error("No data received from GitHub GraphQL API (unknown reason)");
         }
         return json.data;
     }
@@ -983,7 +970,6 @@ class GitHubService {
             return true;
         }
         catch (e) {
-            // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
             if (e.status === 404) {
                 return false;
             }
@@ -1257,8 +1243,7 @@ function getGitHubRepo(snykProject) {
             name: match[2],
         };
     }
-    else if (snykProject.origin === "cli" &&
-        snykProject.remoteRepoUrl != null) {
+    if (snykProject.origin === "cli" && snykProject.remoteRepoUrl != null) {
         // The remoteRepoUrl can be overridden when using the CLI, so don't
         // fail if we cannot extract the value.
         const match = /github.com\/([^/]+)\/(.+)\.git$/.exec(snykProject.remoteRepoUrl);
@@ -1270,9 +1255,7 @@ function getGitHubRepo(snykProject) {
             name: match[2],
         };
     }
-    else {
-        return undefined;
-    }
+    return undefined;
 }
 function getGitHubRepoId(repo) {
     return repo ? `${repo.owner}/${repo.name}` : undefined;
@@ -1424,12 +1407,11 @@ class TestExecutor {
             await body(this);
         }
         catch (error) {
-            // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
             console.error(error.stack || error.message || error);
             process$1.exitCode = 1;
         }
         finally {
-            console.log(`Reached finally block`);
+            console.log("Reached finally block");
             this.usingWithCleanupTasks = false;
             if (this.cleanupTask == null) {
                 this.cleanupTask = this.runTasks();
@@ -1448,8 +1430,8 @@ function createTestExecutor() {
  * Gives a value formatted as "yyyymmdd-xxxxxx", e.g. "20200523-3f2c87".
  */
 function generateRunId() {
-    const low = parseInt("100000", 16);
-    const high = parseInt("ffffff", 16);
+    const low = 0x100000;
+    const high = 0xffffff;
     const range = high - low + 1;
     const now = new Date();
     return [
@@ -1610,7 +1592,7 @@ class OutputPrefixTransform extends Transform {
                 if (result.endsWith("\n\u001B[0m")) {
                     result = result.slice(0, -5) + result.slice(-4);
                 }
-                result = prefix + result.replace(/\n/g, `\n${prefix}`) + "\n";
+                result = `${prefix + result.replace(/\n/g, `\n${prefix}`)}\n`;
                 callback(null, result);
             },
         });
@@ -1739,12 +1721,11 @@ async function startContainer({ executor, network, imageId, alias, env, dockerAr
     executor.registerCleanupTask(async () => {
         console.log(`Stopping container ${containerName}`);
         const r = execa("docker", ["stop", containerName]);
-        pipeToConsole(r, (alias ?? containerName) + " (stop)");
+        pipeToConsole(r, `${alias ?? containerName} (stop)`);
         try {
             await r;
         }
         catch (e) {
-            // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access, @typescript-eslint/no-unsafe-call
             if (!(e.stderr || "").includes("No such container")) {
                 throw e;
             }

package/lib/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}
+{"version":3,"file":"index.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/lib/snyk/service.d.ts

@@ -1,7 +1,7 @@
-import { Config } from "../config";
-import { Definition } from "../definition";
-import { SnykTokenProvider } from "./token";
-import { SnykProject } from "./types";
+import type { Config } from "../config";
+import type { Definition } from "../definition";
+import { type SnykTokenProvider } from "./token";
+import type { SnykProject } from "./types";
 interface SnykServiceProps {
     config: Config;
     tokenProvider: SnykTokenProvider;

package/lib/snyk/util.d.ts

@@ -1,3 +1,3 @@
-import { SnykGitHubRepo, SnykProject } from "./types";
+import type { SnykGitHubRepo, SnykProject } from "./types";
 export declare function getGitHubRepo(snykProject: SnykProject): SnykGitHubRepo | undefined;
 export declare function getGitHubRepoId(repo: SnykGitHubRepo | undefined): string | undefined;

package/lib/sonarcloud/index.d.ts

@@ -1,3 +1,3 @@
 export { createSonarCloudService, SonarCloudService } from "./service";
-export { SonarCloudTokenCliProvider } from "./token";
 export type { SonarCloudTokenProvider } from "./token";
+export { SonarCloudTokenCliProvider } from "./token";

package/lib/sonarcloud/service.d.ts

@@ -1,5 +1,5 @@
-import { Config } from "../config";
-import { SonarCloudTokenProvider } from "./token";
+import type { Config } from "../config";
+import { type SonarCloudTokenProvider } from "./token";
 interface SonarCloudServiceProps {
     config: Config;
     tokenProvider: SonarCloudTokenProvider;

package/lib/testing/lib.d.ts

@@ -1,5 +1,5 @@
 import { type Subprocess } from "execa";
-import { TestExecutor } from "./executor";
+import type { TestExecutor } from "./executor";
 export interface Container {
     id: string;
     name: string;