{
"extends": "sonarqube",
- "plugins": ["header", "eslint-plugin-local-rules"],
+ "plugins": ["header", "typescript-sort-keys", "eslint-plugin-local-rules"],
"ignorePatterns": ["eslint-local-rules/**/*"],
"root": true,
"parserOptions": {
],
"react/jsx-curly-brace-presence": "warn",
"testing-library/render-result-naming-convention": "off",
+ "typescript-sort-keys/interface": "error",
/* Local rules, defined in ./eslint-local-rules/ */
"local-rules/use-componentqualifier-enum": "warn",
"local-rules/use-metrickey-enum": "warn",
"eslint-plugin-react": "7.33.2",
"eslint-plugin-react-hooks": "4.6.0",
"eslint-plugin-testing-library": "6.2.0",
+ "eslint-plugin-typescript-sort-keys": "3.2.0",
"fs-extra": "11.2.0",
"http-proxy": "1.18.1",
"jest": "29.7.0",
field(field: string, options?: { boost?: number }): void;
+ metadataWhitelist?: string[];
+
ref(field: string): void;
use(fn: Function): void;
-
- metadataWhitelist?: string[];
}
export interface LunrBuilder {
- pipeline: any;
metadataWhitelist: string[];
+ pipeline: any;
}
export interface LunrIndex {
}
export interface LunrMatch {
+ matchData: { metadata: any };
ref: string;
score: number;
- matchData: { metadata: any };
}
export interface LunrToken {
- str: string;
metadata: any;
+ str: string;
}
function lunr(initializer: LunrInit): LunrIndex;
export function checkPersonalAccessTokenIsValid(
almSetting: string,
-): Promise<{ status: boolean; error?: string }> {
+): Promise<{ error?: string; status: boolean }> {
return get('/api/alm_integrations/check_pat', { almSetting })
.then(() => ({ status: true }))
.catch(async (response: Response) => {
export function importAzureRepository(data: {
almSetting: string;
- projectName: string;
- repositoryName: string;
newCodeDefinitionType?: string;
newCodeDefinitionValue?: string;
+ projectName: string;
+ repositoryName: string;
}): Promise<{ project: ProjectBase }> {
return postJSON('/api/alm_integrations/import_azure_project', data).catch(throwGlobalError);
}
export function importBitbucketServerProject(data: {
almSetting: string;
- projectKey: string;
- repositorySlug: string;
newCodeDefinitionType?: string;
newCodeDefinitionValue?: string;
+ projectKey: string;
+ repositorySlug: string;
}): Promise<{ project: ProjectBase }> {
return postJSON('/api/alm_integrations/import_bitbucketserver_project', data).catch(
throwGlobalError,
export function importBitbucketCloudRepository(data: {
almSetting: string;
- repositorySlug: string;
newCodeDefinitionType?: string;
newCodeDefinitionValue?: string;
+ repositorySlug: string;
}): Promise<{ project: ProjectBase }> {
return postJSON('/api/alm_integrations/import_bitbucketcloud_repo', data).catch(throwGlobalError);
}
export function importGithubRepository(data: {
almSetting: string;
- repositoryKey: string;
newCodeDefinitionType?: string;
newCodeDefinitionValue?: string;
+ repositoryKey: string;
}): Promise<{ project: ProjectBase }> {
return postJSON('/api/alm_integrations/import_github_project', data).catch(throwGlobalError);
}
export function getGithubRepositories(data: {
almSetting: string;
organization: string;
- pageSize: number;
page?: number;
+ pageSize: number;
query?: string;
-}): Promise<{ repositories: GithubRepository[]; paging: Paging }> {
+}): Promise<{ paging: Paging; repositories: GithubRepository[] }> {
const { almSetting, organization, pageSize, page = 1, query } = data;
return getJSON('/api/alm_integrations/list_github_repositories', {
almSetting,
import { Paging } from '../types/types';
export function getAnalysisStatus(data: {
- component: string;
branch?: string;
+ component: string;
pullRequest?: string;
}): Promise<{
component: {
export function getActivity(
data: ActivityRequestParameters,
-): Promise<{ tasks: Task[]; paging: Paging }> {
+): Promise<{ paging: Paging; tasks: Task[] }> {
return getJSON('/api/ce/activity', data);
}
export function getTasksForComponent(
component: string,
-): Promise<{ queue: Task[]; current?: Task }> {
+): Promise<{ current?: Task; queue: Task[] }> {
return getJSON('/api/ce/component', { component }).catch(throwGlobalError);
}
}
export interface ComponentRaw {
+ analysisDate?: string;
+ isFavorite?: boolean;
key: string;
+ leakPeriodDate?: string;
name: string;
- isFavorite?: boolean;
- analysisDate?: string;
+ needIssueSync?: boolean;
qualifier: ComponentQualifier;
tags: string[];
visibility: Visibility;
- leakPeriodDate?: string;
- needIssueSync?: boolean;
}
export function searchProjectTags(data?: { ps?: number; q?: string }): Promise<any> {
export interface Facet {
property: string;
- values: Array<{ val: string; count: number }>;
+ values: Array<{ count: number; val: string }>;
}
export function searchProjects(data: RequestData): Promise<{
}
export function searchComponents(data?: {
+ ps?: number;
q?: string;
qualifiers?: string;
- ps?: number;
}): Promise<any> {
return getJSON('/api/components/search', data);
}
}
export function getSources(
- data: { key: string; from?: number; to?: number } & BranchParameters,
+ data: { from?: number; key: string; to?: number } & BranchParameters,
): Promise<SourceLine[]> {
return getJSON('/api/sources/lines', data).then((r) => r.sources);
}
const GITLAB_CONFIGURATIONS = '/api/v2/dop-translation/gitlab-configurations';
export function fetchGitLabConfigurations() {
- return axios.get<{ page: Paging; gitlabConfigurations: GitlabConfiguration[] }>(
+ return axios.get<{ gitlabConfigurations: GitlabConfiguration[]; page: Paging }>(
GITLAB_CONFIGURATIONS,
);
}
const GROUPS_MEMBERSHIPS_ENDPOINT = '/api/v2/authorizations/group-memberships';
export function getGroupMemberships(data: {
- userId?: string;
groupId?: string;
- pageSize?: number;
pageIndex?: number;
+ pageSize?: number;
+ userId?: string;
}) {
- return axios.get<{ page: Paging; groupMemberships: GroupMembership[] }>(
+ return axios.get<{ groupMemberships: GroupMembership[]; page: Paging }>(
GROUPS_MEMBERSHIPS_ENDPOINT,
{ params: data },
);
}
-export function addGroupMembership(data: { userId: string; groupId: string }) {
+export function addGroupMembership(data: { groupId: string; userId: string }) {
return axios.post<GroupMembership>(GROUPS_MEMBERSHIPS_ENDPOINT, data);
}
}
export function searchIssueTags(data: {
- project?: string;
- branch?: string;
all?: boolean;
+ branch?: string;
+ project?: string;
ps?: number;
q?: string;
}): Promise<string[]> {
}
export function setIssueAssignee(data: {
- issue: string;
assignee?: string;
+ issue: string;
}): Promise<IssueResponse> {
return postJSON('/api/issues/assign', data);
}
interface EnhancedProjectAlmBindingParam extends ProjectAlmBindingParams {
projectName?: string;
- repositoryName?: string;
repository?: string;
+ repositoryName?: string;
slug?: string;
summaryCommentEnabled?: boolean;
}
prioritizedRule,
}: SearchRulesQuery): Promise<SearchRulesResponse> => {
const standards = await getStandards();
- const facetCounts: Array<{ property: string; values: { val: string; count: number }[] }> = [];
+ const facetCounts: Array<{ property: string; values: { count: number; val: string }[] }> = [];
for (const facet of facets?.split(',') ?? []) {
// If we can count facet values from the list of rules
if (FACET_RULE_MAP[facet]) {
if (tree) {
const { component, ancestors } = tree;
return this.reply({ component, ancestors } as {
- component: ComponentRaw;
ancestors: ComponentRaw[];
+ component: ComponentRaw;
});
}
throw new Error(`Couldn't find component with key ${data.component}`);
return this.reply({ duplications: [], files: {} });
};
- handleGetSources = (data: { key: string; from?: number; to?: number } & BranchParameters) => {
+ handleGetSources = (data: { from?: number; key: string; to?: number } & BranchParameters) => {
const { lines } = this.findSourceFile(data.key);
const from = data.from || 1;
const to = data.to || lines.length;
this.taskWarnings = taskWarnings;
};
- handleAnalysisStatus = (data: { component: string; branch?: string; pullRequest?: string }) => {
+ handleAnalysisStatus = (data: { branch?: string; component: string; pullRequest?: string }) => {
return Promise.resolve({
component: {
key: data.component,
userId,
groupId,
}: {
- userId: string;
groupId: string;
+ userId: string;
}): Promise<GroupMembership> => {
const newMembership = mockGroupMembership({ userId, groupId });
this.memberships.push(newMembership);
this.groups = cloneDeep(this.readOnlyGroups);
}
- handleCreateGroup = (group: { name: string; description?: string }): Promise<Group> => {
+ handleCreateGroup = (group: { description?: string; name: string }): Promise<Group> => {
const newGroup = mockGroup(group);
this.groups.push(newGroup);
return this.reply(newGroup);
return this.getActionsResponse({ severity: data.severity }, data.issue);
};
- handleSetIssueAssignee = (data: { issue: string; assignee?: string }) => {
+ handleSetIssueAssignee = (data: { assignee?: string; issue: string }) => {
return this.getActionsResponse(
{
assignee:
return Promise.resolve(this.componentNavigation);
};
- handleGetMarketplaceNavigation(): Promise<{ serverId: string; ncloc: number }> {
+ handleGetMarketplaceNavigation(): Promise<{ ncloc: number; serverId: string }> {
return Promise.resolve({ serverId: 'foo', ncloc: 0 });
}
};
handleSetNewCodePeriod = (data: {
- project?: string;
branch?: string;
+ project?: string;
type: NewCodeDefinitionType;
value?: string;
}) => {
return this.reply(undefined);
};
- handleResetNewCodePeriod = (data: { project?: string; branch?: string }) => {
+ handleResetNewCodePeriod = (data: { branch?: string; project?: string }) => {
const { branch } = data;
if (branch) {
const index = this.#listBranchesNewCode.findIndex((bNew) => bNew.branchKey === branch);
export default class PermissionsServiceMock {
#permissionTemplates: PermissionTemplate[] = [];
#permissions: Permission[];
- #defaultTemplates: Array<{ templateId: string; qualifier: string }> = [];
+ #defaultTemplates: Array<{ qualifier: string; templateId: string }> = [];
#groups: PermissionGroup[];
#users: PermissionUser[];
#isAllowedToChangePermissions = true;
};
handleGetPermissionTemplateUsers = (data: {
- templateId: string;
- q?: string;
- permission?: string;
p?: number;
+ permission?: string;
ps?: number;
+ q?: string;
+ templateId: string;
}) => {
return this.handleGetPermissionUsers(data);
};
handleGetPermissionTemplateGroups = (data: {
- templateId: string;
- q?: string;
- permission?: string;
p?: number;
+ permission?: string;
ps?: number;
+ q?: string;
+ templateId: string;
}) => {
return this.handleGetPermissionGroups(data);
};
};
handleGetPermissionUsers = (data: {
- q?: string;
- permission?: string;
p?: number;
+ permission?: string;
ps?: number;
+ q?: string;
}) => {
const { ps = PAGE_SIZE, p = DEFAULT_PAGE, q, permission } = data;
};
handleGetPermissionGroups = (data: {
- q?: string;
- permission?: string;
p?: number;
+ permission?: string;
ps?: number;
+ q?: string;
}) => {
const { ps = PAGE_SIZE, p = DEFAULT_PAGE, q, permission } = data;
};
handleGetPermissionGroupsForComponent = (data: {
- projectKey: string;
- q?: string;
- permission?: string;
p?: number;
+ permission?: string;
+ projectKey: string;
ps?: number;
+ q?: string;
}) => {
return this.handleGetPermissionGroups(data);
};
handleGetPermissionUsersForComponent = (data: {
- projectKey: string;
- q?: string;
- permission?: string;
p?: number;
+ permission?: string;
+ projectKey: string;
ps?: number;
+ q?: string;
}) => {
return this.handleGetPermissionUsers(data);
};
handleGrantPermissionToGroup = (data: {
- projectKey?: string;
groupName: string;
permission: string;
+ projectKey?: string;
}) => {
if (!this.#isAllowedToChangePermissions) {
return Promise.reject();
};
handleRevokePermissionFromGroup = (data: {
- projectKey?: string;
groupName: string;
permission: string;
+ projectKey?: string;
}) => {
if (!this.#isAllowedToChangePermissions) {
return Promise.reject();
};
handleGrantPermissionToUser = (data: {
- projectKey?: string;
login: string;
permission: string;
+ projectKey?: string;
}) => {
if (!this.#isAllowedToChangePermissions) {
return Promise.reject();
};
handleRevokePermissionFromUser = (data: {
- projectKey?: string;
login: string;
permission: string;
+ projectKey?: string;
}) => {
if (!this.#isAllowedToChangePermissions) {
return Promise.reject();
};
handleCreatePermissionTemplate = (data: {
- name: string;
description?: string;
+ name: string;
projectKeyPattern?: string;
}) => {
const newTemplate = mockPermissionTemplate({
};
handleUpdatePermissionTemplate = (data: {
- id: string;
description?: string;
+ id: string;
name?: string;
projectKeyPattern?: string;
}) => {
getActivityHandler = (
data: {
- project: string;
- statuses?: string;
category?: string;
from?: string;
p?: number;
+ project: string;
ps?: number;
+ statuses?: string;
} & BranchParameters,
) => {
const { project, ps = PAGE_SIZE, p = DEFAULT_PAGE, category, from } = data;
getAllTimeProjectActivityHandler = (
data: {
- project: string;
- statuses?: string;
category?: string;
from?: string;
p?: number;
+ project: string;
ps?: number;
+ statuses?: string;
} & BranchParameters,
) => {
const { project, p = DEFAULT_PAGE, category, from } = data;
createEventHandler = (data: {
analysis: string;
- name: string;
category?: ProjectAnalysisEventCategory;
description?: string;
+ name: string;
}) => {
const {
analysis: analysisKey,
});
};
- changeEventHandler = (data: { event: string; name: string; description?: string }) => {
+ changeEventHandler = (data: { description?: string; event: string; name: string }) => {
const { event: eventKey, name, description } = data;
const [eventIndex, analysisKey] = this.findEvent(eventKey);
const analysis = this.findAnalysis(analysisKey);
filter = '',
s,
}: {
- ps: number;
facets: string;
filter: string;
+ ps: number;
s?: string;
}) => {
/*
return Promise.resolve();
};
- copyHandler = ({ sourceName, name }: { sourceName: string; name: string }) => {
+ copyHandler = ({ sourceName, name }: { name: string; sourceName: string }) => {
const newQG = cloneDeep(this.list.find((q) => q.name === sourceName));
if (newQG === undefined) {
return Promise.reject({
query,
}: {
gateName: string;
- selected: string;
query: string | undefined;
+ selected: string;
}) => {
let filteredProjects = this.projects;
if (selected === 'selected') {
handleGetSecurityHotspotList = (
hotspotKeys: string[],
data: {
- project: string;
branch?: string;
+ project: string;
},
) => {
if (data?.branch === 'normal-branch') {
};
handleGetSecurityHotspots = (data: {
- project: string;
+ branch?: string;
+ inNewCodePeriod?: boolean;
+ onlyMine?: boolean;
p: number;
+ project: string;
ps: number;
- status?: HotspotStatus;
resolution?: HotspotResolution;
- onlyMine?: boolean;
- inNewCodePeriod?: boolean;
- branch?: string;
+ status?: HotspotStatus;
}) => {
if (data?.branch === 'normal-branch') {
return this.reply({
jest.mocked(encryptValue).mockImplementation(this.handleEcnryptValue);
}
- handleGetValue = (data: { key: string; component?: string } & BranchParameters) => {
+ handleGetValue = (data: { component?: string; key: string } & BranchParameters) => {
const setting = this.#settingValues.find((s) => s.key === data.key) as SettingValue;
const definition = this.#definitions.find(
(d) => d.key === data.key,
return this.reply(setting ?? undefined);
};
- handleGetValues = (data: { keys: string[]; component?: string } & BranchParameters) => {
+ handleGetValues = (data: { component?: string; keys: string[] } & BranchParameters) => {
const settings = data.keys
.map((k) => {
const def = this.#definitions.find((d) => d.key === k);
return this.reply(undefined);
};
- handleResetSettingValue = (data: { keys: string; component?: string } & BranchParameters) => {
+ handleResetSettingValue = (data: { component?: string; keys: string } & BranchParameters) => {
const setting = this.#settingValues.find((s) => s.key === data.keys) as SettingValue;
const definition = this.#definitions.find(
(d) => d.key === data.keys,
jest.mock('../system');
type SystemUpgrades = {
- upgrades: [];
+ installedVersionActive: boolean;
latestLTA: string;
updateCenterRefresh: string;
- installedVersionActive: boolean;
+ upgrades: [];
};
export default class SystemServiceMock {
handleGetAllTimeMachineData = (
data: {
component: string;
- metrics: string;
from?: string;
+ metrics: string;
p?: number;
to?: string;
} & BranchParameters,
projectKey,
expirationDate,
}: {
- name: string;
+ expirationDate?: string;
login: string;
- type: TokenType;
+ name: string;
projectKey: string;
- expirationDate?: string;
+ type: TokenType;
}) => {
if (this.failGeneration) {
this.failGeneration = false;
return Promise.resolve(token);
};
- handleRevokeToken = ({ name }: { name: string; login?: string }) => {
+ handleRevokeToken = ({ name }: { login?: string; name: string }) => {
this.tokens = this.tokens.filter((t) => t.name !== name);
return Promise.resolve();
} from './ids';
export interface ComponentTree {
- component: Component;
ancestors: Component[];
children: ComponentTree[];
+ component: Component;
}
export interface SourceFile {
component: SourceViewerFile;
- lines: SourceLine[];
duplication?: {
duplications: Duplication[];
files: Dict<DuplicatedFile>;
};
+ lines: SourceLine[];
}
export function mockFullComponentTree(
return getJSON('/api/navigation/component', data);
}
-export function getMarketplaceNavigation(): Promise<{ serverId: string; ncloc: number }> {
+export function getMarketplaceNavigation(): Promise<{ ncloc: number; serverId: string }> {
return getJSON('/api/navigation/marketplace').catch(throwGlobalError);
}
} from '../types/new-code-definition';
export function getNewCodeDefinition(data?: {
- project?: string;
branch?: string;
+ project?: string;
}): Promise<Omit<NewCodeDefinition, 'effectiveValue'>> {
return getJSON('/api/new_code_periods/show', data).catch(throwGlobalError);
}
export function setNewCodeDefinition(data: {
- project?: string;
branch?: string;
+ project?: string;
type: NewCodeDefinitionType;
value?: string;
}): Promise<void> {
return post('/api/new_code_periods/set', data).catch(throwGlobalError);
}
-export function resetNewCodeDefinition(data: { project?: string; branch?: string }): Promise<void> {
+export function resetNewCodeDefinition(data: { branch?: string; project?: string }): Promise<void> {
return post('/api/new_code_periods/unset', data).catch(throwGlobalError);
}
const PAGE_SIZE = 100;
export function grantPermissionToUser(data: {
- projectKey?: string;
login: string;
permission: string;
+ projectKey?: string;
}) {
return post('/api/permissions/add_user', data).catch(throwGlobalError);
}
export function revokePermissionFromUser(data: {
- projectKey?: string;
login: string;
permission: string;
+ projectKey?: string;
}) {
return post('/api/permissions/remove_user', data).catch(throwGlobalError);
}
export function grantPermissionToGroup(data: {
- projectKey?: string;
groupName: string;
permission: string;
+ projectKey?: string;
}) {
return post('/api/permissions/add_group', data).catch(throwGlobalError);
}
export function revokePermissionFromGroup(data: {
- projectKey?: string;
groupName: string;
permission: string;
+ projectKey?: string;
}) {
return post('/api/permissions/remove_group', data).catch(throwGlobalError);
}
interface GetPermissionTemplatesResponse {
+ defaultTemplates: Array<{ qualifier: string; templateId: string }>;
permissionTemplates: PermissionTemplate[];
- defaultTemplates: Array<{ templateId: string; qualifier: string }>;
permissions: Array<Permission>;
}
}
export function createPermissionTemplate(data: {
- name: string;
description?: string;
+ name: string;
projectKeyPattern?: string;
}): Promise<{ permissionTemplate: Omit<PermissionTemplate, 'defaultFor'> }> {
return postJSON('/api/permissions/create_template', data);
}
export function updatePermissionTemplate(data: {
- id: string;
description?: string;
+ id: string;
name?: string;
projectKeyPattern?: string;
}): Promise<void> {
}
export function grantTemplatePermissionToUser(data: {
- templateId: string;
login: string;
permission: string;
+ templateId: string;
}): Promise<void> {
return post('/api/permissions/add_user_to_template', data);
}
export function revokeTemplatePermissionFromUser(data: {
- templateId: string;
login: string;
permission: string;
+ templateId: string;
}): Promise<void> {
return post('/api/permissions/remove_user_from_template', data);
}
}
export function getPermissionsUsersForComponent(data: {
- projectKey: string;
- q?: string;
- permission?: string;
p?: number;
+ permission?: string;
+ projectKey: string;
ps?: number;
+ q?: string;
}): Promise<{ paging: Paging; users: PermissionUser[] }> {
if (!data.ps) {
data.ps = PAGE_SIZE;
}
export function getPermissionsGroupsForComponent(data: {
- projectKey: string;
- q?: string;
- permission?: string;
p?: number;
+ permission?: string;
+ projectKey: string;
ps?: number;
-}): Promise<{ paging: Paging; groups: PermissionGroup[] }> {
+ q?: string;
+}): Promise<{ groups: PermissionGroup[]; paging: Paging }> {
if (!data.ps) {
data.ps = PAGE_SIZE;
}
}
export function getGlobalPermissionsUsers(data: {
- q?: string;
- permission?: string;
p?: number;
+ permission?: string;
ps?: number;
+ q?: string;
}): Promise<{ paging: Paging; users: PermissionUser[] }> {
if (!data.ps) {
data.ps = PAGE_SIZE;
}
export function getGlobalPermissionsGroups(data: {
- q?: string;
- permission?: string;
p?: number;
+ permission?: string;
ps?: number;
-}): Promise<{ paging: Paging; groups: PermissionGroup[] }> {
+ q?: string;
+}): Promise<{ groups: PermissionGroup[]; paging: Paging }> {
if (!data.ps) {
data.ps = PAGE_SIZE;
}
}
export function getPermissionTemplateUsers(data: {
- templateId: string;
- q?: string;
- permission?: string;
p?: number;
+ permission?: string;
ps?: number;
+ q?: string;
+ templateId: string;
}): Promise<{ paging: Paging; users: PermissionUser[] }> {
if (data.ps === undefined) {
data.ps = PAGE_SIZE;
}
export function getPermissionTemplateGroups(data: {
- templateId: string;
- q?: string;
- permission?: string;
p?: number;
+ permission?: string;
ps?: number;
-}): Promise<{ paging: Paging; groups: PermissionGroup[] }> {
+ q?: string;
+ templateId: string;
+}): Promise<{ groups: PermissionGroup[]; paging: Paging }> {
if (data.ps === undefined) {
data.ps = PAGE_SIZE;
}
}
export function createProject(data: {
- name: string;
- project: string;
mainBranch: string;
- visibility?: Visibility;
+ name: string;
newCodeDefinitionType?: string;
newCodeDefinitionValue?: string;
+ project: string;
+ visibility?: Visibility;
}): Promise<{ project: ProjectBase }> {
return postJSON('/api/projects/create', data).catch(throwGlobalError);
}
}
export type ProjectActivityParams = {
- project?: string;
- statuses?: string;
category?: string;
from?: string;
p?: number;
+ project?: string;
ps?: number;
+ statuses?: string;
} & BranchParameters;
export interface ProjectActivityResponse {
export interface CreateEventResponse {
analysis: string;
- key: string;
- name: string;
category: ProjectAnalysisEventCategory | ApplicationAnalysisEventCategory;
description?: string;
+ key: string;
+ name: string;
}
export function createEvent(data: {
analysis: string;
- name: string;
category?: string;
description?: string;
+ name: string;
}): Promise<CreateEventResponse> {
return postJSON('/api/project_analyses/create_event', data).then(
(r) => r.event,
}
export function changeEvent(data: {
+ description?: string;
event: string;
name?: string;
- description?: string;
}): Promise<CreateEventResponse> {
return postJSON('/api/project_analyses/update_event', data).then(
(r) => r.event,
return post('/api/qualitygates/rename', data).catch(throwGlobalError);
}
-export function copyQualityGate(data: { sourceName: string; name: string }): Promise<QualityGate> {
+export function copyQualityGate(data: { name: string; sourceName: string }): Promise<QualityGate> {
return postJSON('/api/qualitygates/copy', data).catch(throwGlobalError);
}
export function getQualityGateProjectStatus(
data: {
- projectKey?: string;
projectId?: string;
+ projectKey?: string;
} & BranchParameters,
): Promise<QualityGateProjectStatus> {
return getJSON('/api/qualitygates/project_status', data)
export interface Profile {
actions?: ProfileActions;
+ activeDeprecatedRuleCount: number;
+ activeRuleCount: number;
+ isBuiltIn?: boolean;
+ isDefault?: boolean;
+ isInherited?: boolean;
key: string;
- name: string;
language: string;
languageName: string;
- isInherited?: boolean;
+ lastUsed?: string;
+ name: string;
parentKey?: string;
parentName?: string;
- isDefault?: boolean;
- activeRuleCount: number;
- activeDeprecatedRuleCount: number;
+ projectCount?: number;
rulesUpdatedAt?: string;
- lastUsed?: string;
userUpdatedAt?: string;
- isBuiltIn?: boolean;
- projectCount?: number;
}
export interface SearchQualityProfilesParameters {
}
export interface RuleCompare {
- key: string;
- name: string;
cleanCodeAttributeCategory?: CleanCodeAttributeCategory;
impacts: SoftwareImpact[];
+ key: string;
left?: { params: Dict<string>; severity: string };
+ name: string;
right?: { params: Dict<string>; severity: string };
}
export interface CompareResponse {
- left: { name: string };
- right: { name: string };
inLeft: Array<RuleCompare>;
inRight: Array<RuleCompare>;
+ left: { name: string };
modified: Array<
RuleCompare & {
left: { params: Dict<string>; severity: string };
right: { params: Dict<string>; severity: string };
}
>;
+ right: { name: string };
}
export function compareProfiles(leftKey: string, rightKey: string): Promise<CompareResponse> {
export interface SearchUsersGroupsParameters {
language: string;
- qualityProfile: string;
q?: string;
+ qualityProfile: string;
selected?: 'all' | 'selected' | 'deselected';
}
interface SearchUsersResponse {
- users: UserSelected[];
paging: Paging;
+ users: UserSelected[];
}
export function searchUsers(parameters: SearchUsersGroupsParameters): Promise<SearchUsersResponse> {
export interface ActivateRuleParameters {
key: string;
params?: Dict<string>;
+ prioritizedRule?: boolean;
reset?: boolean;
rule: string;
severity?: string;
- prioritizedRule?: boolean;
}
export function activateRule(data: ActivateRuleParameters) {
const RULES_ENDPOINT = '/api/v2/clean-code-policy/rules';
export interface CreateRuleData {
+ cleanCodeAttribute: CleanCodeAttribute;
+ impacts: SoftwareImpact[];
key: string;
markdownDescription: string;
name: string;
parameters?: Partial<RestRuleParameter>[];
status?: string;
templateKey: string;
- cleanCodeAttribute: CleanCodeAttribute;
- impacts: SoftwareImpact[];
}
export function getRulesApp(): Promise<GetRulesAppResponse> {
}
export function getValue(
- data: { key: string; component?: string } & BranchParameters,
+ data: { component?: string; key: string } & BranchParameters,
): Promise<SettingValue> {
return getValues({ keys: [data.key], component: data.component }).then(([result]) => result);
}
export function getValues(
- data: { keys: string[]; component?: string } & BranchParameters,
+ data: { component?: string; keys: string[] } & BranchParameters,
): Promise<SettingValue[]> {
return getJSON('/api/settings/values', {
keys: data.keys.join(','),
}
export function setSimpleSettingValue(
- data: { component?: string; value?: string; values?: string[]; key: string } & BranchParameters,
+ data: { component?: string; key: string; value?: string; values?: string[] } & BranchParameters,
): Promise<void | Response> {
return post('/api/settings/set', data).catch(throwGlobalError);
}
export function resetSettingValue(
- data: { keys: string; component?: string } & BranchParameters,
+ data: { component?: string; keys: string } & BranchParameters,
): Promise<void> {
return post('/api/settings/reset', data);
}
return getJSON('/api/system/info').catch(throwGlobalError);
}
-export function getSystemStatus(): Promise<{ id: string; version: string; status: SysStatus }> {
+export function getSystemStatus(): Promise<{ id: string; status: SysStatus; version: string }> {
return getJSON('/api/system/status');
}
export function getSystemUpgrades(): Promise<{
- upgrades: SystemUpgrade[];
- latestLTA?: string;
installedVersionActive?: boolean;
+ latestLTA?: string;
updateCenterRefresh?: string;
+ upgrades: SystemUpgrade[];
}> {
return getJSON('/api/system/upgrades');
}
export function waitSystemUPStatus(): Promise<{
id: string;
- version: string;
status: SysStatus;
+ version: string;
}> {
return requestTryAndRepeatUntil(
getSystemStatus,
export interface TimeMachineResponse {
measures: {
- metric: MetricKey;
history: Array<{ date: string; value?: string }>;
+ metric: MetricKey;
}[];
paging: Paging;
}
export function getAllTimeMachineData(
data: {
component?: string;
- metrics: string;
from?: string;
+ metrics: string;
p?: number;
to?: string;
} & BranchParameters,
}
export function generateToken(data: {
+ expirationDate?: string;
+ login?: string;
name: string;
projectKey?: string;
type?: string;
- login?: string;
- expirationDate?: string;
}): Promise<NewUserToken> {
return postJSON('/api/user_tokens/generate', data).catch(throwGlobalError);
}
-export function revokeToken(data: { name: string; login?: string }) {
+export function revokeToken(data: { login?: string; name: string }) {
return post('/api/user_tokens/revoke', data).catch(throwGlobalError);
}
const GROUPS_ENDPOINT = '/api/v2/authorizations/groups';
export function getUsersGroups(params: {
- q?: string;
managed?: boolean;
pageIndex?: number;
pageSize?: number;
+ q?: string;
}): Promise<{ groups: Group[]; page: Paging }> {
return axios.get(GROUPS_ENDPOINT, { params });
}
export function updateGroup(
id: string,
data: {
- name?: string;
description?: string;
+ name?: string;
},
) {
return axios.patch(`${GROUPS_ENDPOINT}/${id}`, data);
}
export function getUsers<T extends RestUserBase>(data: {
- q: string;
active?: boolean;
+ groupId?: string;
+ 'groupId!'?: string;
managed?: boolean;
- sonarQubeLastConnectionDateFrom?: string;
- sonarQubeLastConnectionDateTo?: string;
+ pageIndex?: number;
+ pageSize?: number;
+ q: string;
sonarLintLastConnectionDateFrom?: string;
sonarLintLastConnectionDateTo?: string;
- pageSize?: number;
- pageIndex?: number;
- groupId?: string;
- 'groupId!'?: string;
+ sonarQubeLastConnectionDateFrom?: string;
+ sonarQubeLastConnectionDateTo?: string;
}) {
return axios.get<{ page: Paging; users: T[] }>(USERS_ENDPOINT, {
params: data,
return axiosToCatch.patch<RestUserDetailed>(`${USERS_ENDPOINT}/${id}`, data);
}
-export function deleteUser({ id, anonymize }: { id: string; anonymize?: boolean }) {
+export function deleteUser({ id, anonymize }: { anonymize?: boolean; id: string }) {
return axios.delete(`${USERS_ENDPOINT}/${id}`, { params: { anonymize } });
}
}
interface State {
+ adminPages: Extension[];
pendingPlugins: PendingPluginResult;
systemStatus: SysStatus;
- adminPages: Extension[];
}
export class AdminContainer extends React.PureComponent<AdminContainerProps, State> {
import { SysStatus } from '../../types/types';
export interface AdminContextInterface {
- fetchSystemStatus: () => void;
fetchPendingPlugins: () => void;
+ fetchSystemStatus: () => void;
pendingPlugins: PendingPluginResult;
systemStatus: SysStatus;
}
import withAppStateContext from './app-state/withAppStateContext';
interface Props {
- location: Location;
appState: AppState;
+ location: Location;
}
interface State {
const HISTORY_LIMIT = 10;
export type History = Array<{
+ icon: string;
key: string;
name: string;
- icon: string;
}>;
export default class RecentHistory {
import withCurrentUserContext from './current-user/withCurrentUserContext';
interface Props {
- currentUser: CurrentUser;
appState: AppState;
+ currentUser: CurrentUser;
}
interface State {
description: string;
key: string;
name: string;
- visibility: Visibility;
submitting: boolean;
+ visibility: Visibility;
}
export default class CreateApplicationForm extends React.PureComponent<Props, State> {
import { ComponentResult, More, Results, sortQualifiers } from './utils';
export interface Props {
- query: string;
loadingMore?: string;
more: More;
onMoreClick: (qualifier: string) => void;
onSelect: (componentKey: string) => void;
+ query: string;
renderNoResults: () => React.ReactElement;
renderResult: (component: ComponentResult) => React.ReactNode;
results: Results;
pathname,
additionalQueryParams = {},
}: {
+ additionalQueryParams?: Dict<string>;
label: string;
pathname: string;
- additionalQueryParams?: Dict<string>;
}) => {
const query = getQuery();
if (isApplicationChildInaccessble) {
import { Component } from '../../../../../types/types';
interface Props {
+ branchSupportEnabled: boolean;
+ canAdminComponent?: boolean;
component: Component;
- isApplication: boolean;
hasManyBranches: boolean;
- canAdminComponent?: boolean;
- branchSupportEnabled: boolean;
+ isApplication: boolean;
}
export default function BranchHelpTooltip({
export interface MenuItemProps {
branchLike: BranchLike;
+ indent: boolean;
onSelect: (branchLike: BranchLike) => void;
selected: boolean;
- indent: boolean;
setSelectedNode?: (node: HTMLLIElement) => void;
}
currentBranchLike,
component,
}: Readonly<{
- currentBranchLike: BranchLike;
component: Component;
+ currentBranchLike: BranchLike;
}>) {
if (!isPullRequest(currentBranchLike)) {
return null;
import ProjectCard from './ProjectCard';
interface Props {
- loading: boolean;
loadMore: () => void;
+ loading: boolean;
projects: MyProject[];
total?: number;
}
export interface AuditAppRendererProps {
dateRange?: { from?: Date; to?: Date };
downloadStarted: boolean;
- handleOptionSelection: (option: RangeOption) => void;
handleDateSelection: (dateRange: { from?: Date; to?: Date }) => void;
+ handleOptionSelection: (option: RangeOption) => void;
handleStartDownload: () => void;
housekeepingPolicy: HousekeepingPolicy;
selection: RangeOption;
}
interface State {
- loading: boolean;
dismissedWarning?: string;
+ loading: boolean;
warnings: TaskWarning[];
}
import { CURRENTS } from '../constants';
interface CurrentsFilterProps {
- value?: string;
onChange: (value: string) => void;
+ value?: string;
}
export default function CurrentsFilter(props: Readonly<CurrentsFilterProps>) {
component?: unknown;
currents: string;
loading: boolean;
+ maxExecutedAt: Date | undefined;
+ minSubmittedAt: Date | undefined;
onFilterUpdate: (changes: Partial<Query>) => void;
onReload: () => void;
query: string;
status: string;
taskType: string;
- maxExecutedAt: Date | undefined;
- minSubmittedAt: Date | undefined;
types: string[];
}
import { STATUSES } from '../constants';
interface StatusFilterProps {
- value?: string;
id: string;
onChange: (value?: string) => void;
+ value?: string;
}
export default function StatusFilter(props: Readonly<StatusFilterProps>) {
import { isValidDate, parseDate } from '../../../helpers/dates';
interface Props {
- date?: string;
baseDate?: string;
+ date?: string;
}
export default function TaskDate({ date, baseDate }: Readonly<Props>) {
import Task from './Task';
interface Props {
- tasks: ITask[];
component?: unknown;
onCancelTask: (task: ITask) => Promise<void>;
onFilterTask: (task: ITask) => void;
+ tasks: ITask[];
}
const COLUMN_WIDTHS = [0, 'auto', 'auto', 0, 0, 0, 0];
import { ALL_TYPES } from '../constants';
interface Props {
- value: string;
id: string;
onChange: Function;
types: string[];
+ value: string;
}
export default class TypesFilter extends React.PureComponent<Props> {
}
interface State {
- passwordValue: string;
- confirmPasswordValue: string;
canSubmit?: boolean;
+ confirmPasswordValue: string;
+ passwordValue: string;
submitting: boolean;
success: boolean;
}
import SourceViewerWrapper from './SourceViewerWrapper';
interface Props {
- branchLike?: BranchLike;
- component: Component;
- location: Location;
- metrics: Dict<Metric>;
baseComponent?: ComponentMeasure;
+ branchLike?: BranchLike;
breadcrumbs: Breadcrumb[];
+ component: Component;
components?: ComponentMeasure[];
- highlighted?: ComponentMeasure;
- loading: boolean;
- searchResults?: ComponentMeasure[];
- sourceViewer?: ComponentMeasure;
- total: number;
- newCodeSelected: boolean;
-
handleGoToParent: () => void;
handleHighlight: (highlighted: ComponentMeasure) => void;
handleLoadMore: () => void;
handleSearchResults: (searchResults: ComponentMeasure[]) => void;
handleSelect: (component: ComponentMeasure) => void;
handleSelectNewCode: (newCodeSelected: boolean) => void;
+ highlighted?: ComponentMeasure;
+
+ loading: boolean;
+ location: Location;
+ metrics: Dict<Metric>;
+ newCodeSelected: boolean;
+ searchResults?: ComponentMeasure[];
+ sourceViewer?: ComponentMeasure;
+ total: number;
}
export default function CodeAppRenderer(props: Readonly<Props>) {
component: TypeComponentMeasure;
isBaseComponent?: boolean;
metrics: Metric[];
+ newCodeSelected?: boolean;
previous?: TypeComponentMeasure;
rootComponent: TypeComponentMeasure;
selected?: boolean;
- newCodeSelected?: boolean;
showAnalysisDate?: boolean;
}
branchLike?: BranchLike;
components: ComponentMeasure[];
metrics: Metric[];
+ newCodeSelected?: boolean;
rootComponent: ComponentMeasure;
selected?: ComponentMeasure;
- newCodeSelected?: boolean;
showAnalysisDate?: boolean;
}
component: ComponentMeasure;
location: Location;
newCodeSelected: boolean;
- onSearchClear: () => void;
onNewCodeToggle: (newCode: boolean) => void;
+ onSearchClear: () => void;
onSearchResults: (results?: ComponentMeasure[]) => void;
router: Router;
}
interface State {
- query: string;
loading: boolean;
+ query: string;
}
class Search extends React.PureComponent<Props, State> {
interface Props {
activation: RuleActivation;
+ canDeactivateInherited?: boolean;
+ handleDeactivate: (key?: string) => void;
+ handleRevert: (key?: string) => void;
+ onActivate: (severity: string, prioritizedRule: boolean) => Promise<void> | void;
profile: Profile;
ruleDetails: Rule;
- onActivate: (severity: string, prioritizedRule: boolean) => Promise<void> | void;
- handleRevert: (key?: string) => void;
- handleDeactivate: (key?: string) => void;
showDeactivated?: boolean;
- canDeactivateInherited?: boolean;
}
export default function ActivatedRuleActions(props: Readonly<Props>) {
interface Props {
activation?: RuleActivation;
+ ariaLabel?: string;
buttonText: string;
className?: string;
modalHeader: string;
onDone?: (severity: string, prioritizedRule: boolean) => Promise<void> | void;
profiles: BaseProfile[];
rule: Rule | RuleDetails;
- ariaLabel?: string;
}
export default function ActivationButton(props: Props) {
interface State {
actives?: Actives;
- canWrite?: boolean;
canDeactivateInherited?: boolean;
+ canWrite?: boolean;
facets?: Facets;
loading: boolean;
openFacets: OpenFacets;
} from '../../../types/clean-code-taxonomy';
interface Props<T> {
- value: T;
- onChange: (value: T) => void;
disabled?: boolean;
+ onChange: (value: T) => void;
+ value: T;
}
export function CleanCodeCategoryField(props: Readonly<Props<CleanCodeAttributeCategory>>) {
import { FacetKey } from '../query';
export interface BasicProps {
+ help?: React.ReactNode;
onChange: (changes: Dict<string | string[] | undefined>) => void;
onToggle: (facet: FacetKey) => void;
open: boolean;
stats?: Dict<number>;
values: string[];
- help?: React.ReactNode;
}
interface Props extends BasicProps {
import Facet, { BasicProps } from './Facet';
interface Props extends Omit<BasicProps, 'onChange' | 'values'> {
- onChange: (changes: { prioritizedRule: boolean | undefined }) => void;
disabled: boolean;
+ onChange: (changes: { prioritizedRule: boolean | undefined }) => void;
value: boolean | undefined;
}
interface Props {
inputId?: string;
- profiles: Profile[];
onChange: (selected: Profile[]) => void;
+ profiles: Profile[];
selectedProfiles: Profile[];
}
interface Props {
allowCustomRules?: boolean;
- canWrite?: boolean;
canDeactivateInherited?: boolean;
+ canWrite?: boolean;
onActivate: (profile: string, rule: string, activation: RuleActivation) => void;
onDeactivate: (profile: string, rule: string) => void;
onDelete: (rule: string) => void;
function RuleListItem(
props: Readonly<{
- rule: Rule;
editable?: boolean;
onDelete: (ruleKey: string) => void;
+ rule: Rule;
}>,
) {
const { rule, editable } = props;
const EXTERNAL_RULE_REPO_PREFIX = 'external_';
interface Props {
- ruleDetails: RuleDetails;
referencedRepositories: Dict<{ key: string; language: string; name: string }>;
+ ruleDetails: RuleDetails;
}
export default function RuleDetailsHeaderMeta(props: Readonly<Props>) {
interface RuleHeaderMetaItemProps {
children: React.ReactNode;
- title: string;
className?: string;
+ title: string;
}
function RuleHeaderInfo({ children, title, ...props }: Readonly<RuleHeaderMetaItemProps>) {
interface Props {
activation?: RuleActivation;
- isLoggedIn: boolean;
canDeactivateInherited?: boolean;
+ isLoggedIn: boolean;
onActivate: (profile: string, rule: string, activation: RuleActivation) => void;
onDeactivate: (profile: string, rule: string) => void;
onOpen: (ruleKey: string) => void;
rule: Rule;
- selected: boolean;
selectRule: (key: string) => void;
+ selected: boolean;
selectedProfile?: Profile;
}
export interface SeveritySelectProps {
isDisabled: boolean;
- severity: string;
onChange: (value: LabelValueSelectOption<IssueSeverity>) => void;
+ severity: string;
}
function Option(props: Readonly<OptionProps<LabelValueSelectOption<IssueSeverity>, false>>) {
languages: string[];
owaspTop10: string[];
'owaspTop10-2021': string[];
+ prioritizedRule: boolean | undefined;
profile: string | undefined;
repositories: string[];
ruleKey: string | undefined;
tags: string[];
template: boolean | undefined;
types: string[];
- prioritizedRule: boolean | undefined;
}
export type FacetKey = keyof Query;
}
export interface RuleDescriptionContext {
- key: string;
displayName: string;
+ key: string;
}
export interface RuleDescriptionSection {
- key: RuleDescriptionSections;
content: string;
context?: RuleDescriptionContext;
+ key: RuleDescriptionSections;
}
import MeasuresBreadcrumbs from './MeasuresBreadcrumbs';
interface Props {
+ asc?: boolean;
branchLike?: BranchLike;
leakPeriod?: Period;
- requestedMetric: Pick<Metric, 'key' | 'direction'>;
metrics: Dict<Metric>;
+ requestedMetric: Pick<Metric, 'key' | 'direction'>;
rootComponent: ComponentMeasure;
router: Router;
selected?: string;
- asc?: boolean;
updateQuery: (query: Partial<Query>) => void;
view: MeasurePageView;
}
export interface MeasureViewSelectProps {
className?: string;
- metric: Metric;
handleViewChange: (view: MeasurePageView) => void;
+ metric: Metric;
view: MeasurePageView;
}
export const bubbles: {
[domain: string]: {
+ colors?: string[];
+ size: string;
x: string;
y: string;
- size: string;
- colors?: string[];
yDomain?: [number, number];
};
} = {
const HEIGHT = 500;
interface Props {
+ branchLike?: BranchLike;
component: ComponentMeasureI;
components: ComponentMeasureEnhanced[];
- branchLike?: BranchLike;
domain: string;
metrics: Dict<Metric>;
paging?: Paging;
getTooltip(
component: ComponentMeasureEnhanced,
- values: { x: number; y: number; size: number; colors?: Array<number | undefined> },
- metrics: { x: Metric; y: Metric; size: Metric; colors?: Metric[] },
+ values: { colors?: Array<number | undefined>; size: number; x: number; y: number },
+ metrics: { colors?: Metric[]; size: Metric; x: Metric; y: Metric },
) {
const inner = [
[component.name, isProject(component.qualifier) ? component.branch : undefined]
return translatedDescription;
}
- renderBubbleChart(metrics: { x: Metric; y: Metric; size: Metric; colors?: Metric[] }) {
+ renderBubbleChart(metrics: { colors?: Metric[]; size: Metric; x: Metric; y: Metric }) {
const { ratingFilters } = this.state;
const items = this.props.components
components: ComponentMeasureEnhanced[];
defaultShowBestMeasures: boolean;
fetchMore: () => void;
- handleSelect: (component: ComponentMeasureEnhanced) => void;
handleOpen: (component: ComponentMeasureEnhanced) => void;
+ handleSelect: (component: ComponentMeasureEnhanced) => void;
loadingMore: boolean;
metric: Metric;
metrics: Dict<Metric>;
}));
return sortBy(domains, [
- (domain: { name: string; measures: MeasureEnhanced[] }) => {
+ (domain: { measures: MeasureEnhanced[]; name: string }) => {
const idx = KNOWN_DOMAINS.indexOf(domain.name);
return idx >= 0 ? idx : KNOWN_DOMAINS.length;
},
}
export interface Query {
+ asc?: boolean;
metric: string;
selected?: string;
view: MeasurePageView;
- asc?: boolean;
}
export const parseQuery = memoize((urlQuery: RawQuery): Query => {
export interface AzureProjectAccordionProps {
loading: boolean;
- onOpen: (key: string) => void;
onImportRepository: (repository: AzureRepository) => void;
+ onOpen: (key: string) => void;
project: AzureProject;
repositories?: AzureRepository[];
searchQuery?: string;
import AzureProjectsList from './AzureProjectsList';
export interface AzureProjectCreateRendererProps {
+ almInstances?: AlmSettingsInstance[];
loading: boolean;
loadingRepositories: Dict<boolean>;
onImportRepository: (resository: AzureRepository) => void;
onOpenProject: (key: string) => void;
onPersonalAccessTokenCreate: () => void;
onSearch: (query: string) => void;
+ onSelectedAlmInstanceChange: (instance: AlmSettingsInstance) => void;
projects?: AzureProject[];
repositories?: Dict<AzureRepository[]>;
- searching?: boolean;
- searchResults?: AzureRepository[];
+ resetPat: boolean;
searchQuery?: string;
- almInstances?: AlmSettingsInstance[];
+ searchResults?: AzureRepository[];
+ searching?: boolean;
selectedAlmInstance?: AlmSettingsInstance;
showPersonalAccessTokenForm?: boolean;
- resetPat: boolean;
- onSelectedAlmInstanceChange: (instance: AlmSettingsInstance) => void;
}
export default function AzureProjectCreateRenderer(
export interface AzureProjectsListProps {
loadingRepositories: Dict<boolean>;
- onOpenProject: (key: string) => void;
onImportRepository: (repository: AzureRepository) => void;
+ onOpenProject: (key: string) => void;
projects?: AzureProject[];
repositories?: Dict<AzureRepository[]>;
- searchResults?: AzureRepository[];
searchQuery?: string;
+ searchResults?: AzureRepository[];
}
const PAGE_SIZE = 10;
interface Props {
almSetting: AlmInstanceBase;
- resetPat: boolean;
onPersonalAccessTokenCreated: () => void;
+ resetPat: boolean;
}
export default function BitbucketCloudPersonalAccessTokenForm({
onSelectedAlmInstanceChange: (instance: AlmSettingsInstance) => void;
repositories?: BitbucketCloudRepository[];
resetPat: boolean;
- searching: boolean;
searchQuery: string;
+ searching: boolean;
selectedAlmInstance?: AlmSettingsInstance;
showPersonalAccessTokenForm: boolean;
}
onLoadMore: () => void;
onSearch: (searchQuery: string) => void;
repositories?: BitbucketCloudRepository[];
- searching: boolean;
searchQuery: string;
+ searching: boolean;
}
function getRepositoryUrl(workspace: string, slug: string) {
import BitbucketSearchResults from './BitbucketSearchResults';
export interface BitbucketImportRepositoryFormProps {
- onSearch: (query: string) => void;
onImportRepository: (repo: BitbucketRepository) => void;
- projects?: BitbucketProject[];
+ onSearch: (query: string) => void;
projectRepositories?: Dict<BitbucketRepository[]>;
- searching: boolean;
+ projects?: BitbucketProject[];
searchResults?: BitbucketRepository[];
+ searching: boolean;
}
export default function BitbucketImportRepositoryForm(props: BitbucketImportRepositoryFormProps) {
almInstances: AlmSettingsInstance[];
isLoading: boolean;
onImportRepository: (repository: BitbucketRepository) => void;
- onSearch: (query: string) => void;
onPersonalAccessTokenCreated: () => void;
+ onSearch: (query: string) => void;
onSelectedAlmInstanceChange: (instance: AlmSettingsInstance) => void;
- projects?: BitbucketProject[];
projectRepositories?: Dict<BitbucketRepository[]>;
+ projects?: BitbucketProject[];
resetPat: boolean;
- searching: boolean;
searchResults?: BitbucketRepository[];
+ searching: boolean;
selectedAlmInstance?: AlmSettingsInstance;
showPersonalAccessTokenForm?: boolean;
}
export interface BitbucketRepositoriesProps {
onImportRepository: (repo: BitbucketRepository) => void;
- projects: BitbucketProject[];
projectRepositories: Dict<BitbucketRepository[]>;
+ projects: BitbucketProject[];
}
export default function BitbucketRepositories(props: BitbucketRepositoriesProps) {
export interface BitbucketSearchResultsProps {
onImportRepository: (repo: BitbucketRepository) => void;
projects: BitbucketProject[];
- searching: boolean;
searchResults?: BitbucketRepository[];
+ searching: boolean;
}
export default function BitbucketSearchResults(props: BitbucketSearchResultsProps) {
interface Props {
almSetting: AlmInstanceBase;
- resetPat: boolean;
onPersonalAccessTokenCreated: () => void;
+ resetPat: boolean;
}
export default function BitbucketServerPersonalAccessTokenForm({
interface State {
azureSettings: DopSetting[];
- bitbucketSettings: DopSetting[];
bitbucketCloudSettings: DopSetting[];
+ bitbucketSettings: DopSetting[];
+ creatingAlmDefinition?: AlmKeys;
githubSettings: DopSetting[];
gitlabSettings: DopSetting[];
- loading: boolean;
- creatingAlmDefinition?: AlmKeys;
importProjects?: ImportProjectParam;
+ loading: boolean;
redirectTo: string;
}
export type ImportProjectParam =
| {
- creationMode: CreateProjectModes.AzureDevOps;
almSetting: string;
+ creationMode: CreateProjectModes.AzureDevOps;
monorepo: false;
projects: {
projectName: string;
}[];
}
| {
- creationMode: CreateProjectModes.BitbucketCloud;
almSetting: string;
+ creationMode: CreateProjectModes.BitbucketCloud;
monorepo: false;
projects: {
repositorySlug: string;
}[];
}
| {
- creationMode: CreateProjectModes.BitbucketServer;
almSetting: string;
+ creationMode: CreateProjectModes.BitbucketServer;
monorepo: false;
projects: {
- repositorySlug: string;
projectKey: string;
+ repositorySlug: string;
}[];
}
| {
- creationMode: CreateProjectModes.GitHub;
almSetting: string;
+ creationMode: CreateProjectModes.GitHub;
monorepo: false;
projects: {
repositoryKey: string;
}[];
}
| {
- creationMode: CreateProjectModes.GitLab;
almSetting: string;
+ creationMode: CreateProjectModes.GitLab;
monorepo: false;
projects: {
gitlabProjectId: string;
creationMode: CreateProjectModes.Manual;
monorepo: false;
projects: {
- project: string;
- name: string;
mainBranch: string;
+ name: string;
+ project: string;
}[];
}
| {
creationMode: CreateProjectModes;
devOpsPlatformSettingId: string;
monorepo: true;
+ projectIdentifier?: string;
projects: {
projectKey: string;
projectName: string;
}[];
- projectIdentifier?: string;
repositoryIdentifier: string;
};
import { redirectToGithub } from './utils';
interface Props {
+ dopSettings: DopSetting[];
isLoadingBindings: boolean;
onProjectSetupDone: (importProjects: ImportProjectParam) => void;
- dopSettings: DopSetting[];
}
export default function GitHubProjectCreate(props: Readonly<Props>) {
import { CreateProjectModes } from '../types';
interface GitHubProjectCreateRendererProps {
+ almInstances: AlmSettingsInstance[];
error: boolean;
loadingBindings: boolean;
loadingOrganizations: boolean;
onLoadMore: () => void;
onSearch: (q: string) => void;
onSelectOrganization: (key: string) => void;
+ onSelectedAlmInstanceChange: (instance: AlmSettingsInstance) => void;
organizations?: GithubOrganization[];
repositories?: GithubRepository[];
repositoryPaging: Paging;
searchQuery: string;
- selectedOrganization?: GithubOrganization;
- almInstances: AlmSettingsInstance[];
selectedAlmInstance?: AlmSettingsInstance;
- onSelectedAlmInstanceChange: (instance: AlmSettingsInstance) => void;
+ selectedOrganization?: GithubOrganization;
}
function orgToOption({ key, name }: GithubOrganization) {
interface Props {
almSetting: AlmInstanceBase;
- resetPat: boolean;
onPersonalAccessTokenCreated: () => void;
+ resetPat: boolean;
}
export default function GitlabPersonalAccessTokenForm({
import GitlabProjectCreateRenderer from './GitlabProjectCreateRenderer';
interface Props {
+ dopSettings: DopSetting[];
isLoadingBindings: boolean;
onProjectSetupDone: (importProjects: ImportProjectParam) => void;
- dopSettings: DopSetting[];
}
export default function GitlabProjectCreate(props: Readonly<Props>) {
onLoadMore: () => void;
onPersonalAccessTokenCreated: () => void;
onSearch: (searchQuery: string) => void;
+ onSelectedAlmInstanceChange: (instance: AlmInstanceBase) => void;
projects?: GitlabProject[];
projectsPaging: Paging;
resetPat: boolean;
searchQuery: string;
selectedAlmInstance?: AlmSettingsInstance;
- onSelectedAlmInstanceChange: (instance: AlmInstanceBase) => void;
showPersonalAccessTokenForm?: boolean;
}
onSearch: (searchQuery: string) => void;
projects?: GitlabProject[];
projectsPaging: Paging;
- searching: boolean;
searchQuery: string;
+ searching: boolean;
}
export default function GitlabProjectSelectionForm(
import { getProjectUrl } from '../../../../helpers/urls';
type AlmRepoItemProps = {
- primaryTextNode: React.ReactNode;
- secondaryTextNode?: React.ReactNode;
- sqProjectKey?: string;
+ almIconSrc: string;
almKey: string;
almUrl?: string;
almUrlText?: string;
- almIconSrc: string;
+ primaryTextNode: React.ReactNode;
+ secondaryTextNode?: React.ReactNode;
+ sqProjectKey?: string;
} & (
| {
multiple: true;
onCheck: (key: string) => void;
- selected: boolean;
onImport?: never;
+ selected: boolean;
}
| {
multiple?: false;
onCheck?: never;
- selected?: never;
onImport: (key: string) => void;
+ selected?: never;
}
);
);
}
-const RepositoryItem = styled.li<{ selected?: boolean; imported?: boolean }>`
+const RepositoryItem = styled.li<{ imported?: boolean; selected?: boolean }>`
box-sizing: border-box;
border: ${({ selected }) =>
selected ? themeBorder('default', 'primary') : themeBorder('default')};
import { AlmKeys, AlmSettingsInstance } from '../../../../types/alm-settings';
interface Props {
- almKey: AlmKeys;
almInstances?: AlmSettingsInstance[];
- selectedAlmInstance?: AlmSettingsInstance;
+ almKey: AlmKeys;
onChangeConfig: (instance: AlmSettingsInstance) => void;
+ selectedAlmInstance?: AlmSettingsInstance;
}
const MIN_SIZE_INSTANCES = 2;
}
interface State {
- name: string;
- nameError?: boolean;
- nameTouched: boolean;
key: string;
keyError?: ProjectKeyErrors;
keyTouched: boolean;
+ name: string;
+ nameError?: boolean;
+ nameTouched: boolean;
validatingKey: boolean;
}
export interface ProjectData<I = string> {
hasError: boolean;
id?: I;
- name: string;
key: string;
+ name: string;
touched: boolean;
}
import AlmRepoItem from '../components/AlmRepoItem';
interface RepositoryListProps {
+ almKey: AlmKeys.GitHub | AlmKeys.GitLab;
+ checkAll: () => void;
loadingRepositories: boolean;
+ onCheck: (key: string) => void;
+ onImport: () => void;
+ onLoadMore: () => void;
+ onSearch: (query: string) => void;
repositories?: GithubRepository[] | GitlabProject[];
repositoryPaging: Paging;
searchQuery: string;
- onLoadMore: () => void;
- onSearch: (query: string) => void;
- almKey: AlmKeys.GitHub | AlmKeys.GitLab;
selected: Set<string>;
- checkAll: () => void;
uncheckAll: () => void;
- onCheck: (key: string) => void;
- onImport: () => void;
}
export default function RepositoryList(props: Readonly<RepositoryListProps>) {
interface Props {
branchesEnabled: boolean;
- onProjectSetupDone: (importProjects: ImportProjectParam) => void;
onClose: () => void;
+ onProjectSetupDone: (importProjects: ImportProjectParam) => void;
}
interface MainBranchState {
selectedDopSetting?: DopSetting;
selectedOrganization?: LabelValueSelectOption;
selectedRepository?: LabelValueSelectOption;
- showPersonalAccessToken?: boolean;
showOrganizations?: boolean;
+ showPersonalAccessToken?: boolean;
}
export function MonorepoConnectionSelector({
import { ProjectData, ProjectValidationCard } from '../components/ProjectValidation';
interface Props {
- projectKeys: string[];
onAddProject: () => void;
onChangeProject: (project: ProjectData<number>) => void;
onRemoveProject: (id?: number) => void;
+ projectKeys: string[];
projects: ProjectData<number>[];
}
loadingRepositories: boolean;
onSearchRepositories: (query: string) => void;
onSelectRepository: (repositoryKey: string) => void;
- repositorySearchQuery: string;
repositoryOptions?: LabelValueSelectOption[] | GroupBase<LabelValueSelectOption>[];
+ repositorySearchQuery: string;
selectedOrganization?: LabelValueSelectOption;
selectedRepository?: LabelValueSelectOption;
showOrganizations?: boolean;
import { tokenExistedBefore } from './utils';
export interface PATType {
- validationFailed: boolean;
- validationErrorMessage?: string;
- touched: boolean;
- password: string;
- username?: string;
- submitting: boolean;
checkingPat: boolean;
firstConnection: boolean;
- handleUsernameChange: (event: React.ChangeEvent<HTMLInputElement>) => void;
handlePasswordChange: (event: React.ChangeEvent<HTMLInputElement>) => void;
handleSubmit: (e: React.SyntheticEvent<HTMLFormElement>) => Promise<void>;
+ handleUsernameChange: (event: React.ChangeEvent<HTMLInputElement>) => void;
+ password: string;
+ submitting: boolean;
+ touched: boolean;
+ username?: string;
+ validationErrorMessage?: string;
+ validationFailed: boolean;
}
export const usePersonalAccessToken = (
import ViewMembersModal from './ViewMembersModal';
interface Props {
- isManaged: boolean;
group: Group;
+ isManaged: boolean;
onEdit: () => void;
}
import { Group } from '../../../types/types';
interface Props {
- isManaged: boolean;
group: Group;
+ isManaged: boolean;
onClose: () => void;
}
export interface AssigneeSelectProps {
assignee?: SingleValue<LabelValueSelectOption>;
className?: string;
+ inputId: string;
issues: Issue[];
onAssigneeSelect: (assignee: SingleValue<LabelValueSelectOption>) => void;
- inputId: string;
}
function userToOption(user: RestUser | UserActive) {
import IssueNewStatusAndTransitionGuide from './IssueNewStatusAndTransitionGuide';
interface Props {
- issue: Issue;
- ruleDetails: RuleDetails;
branchLike?: BranchLike;
+ issue: Issue;
onIssueChange: (issue: Issue) => void;
+ ruleDetails: RuleDetails;
}
interface State {
interface IssueHeaderMetaItemProps extends React.HTMLAttributes<HTMLDivElement> {
children: React.ReactNode;
- title: string;
className?: string;
+ title: string;
}
function IssueHeaderInfo({
import { NoticeType } from '../../../types/users';
interface Props {
+ issues: Issue[];
run?: boolean;
togglePopup: (issue: string, popup: string, show?: boolean) => void;
- issues: Issue[];
}
const PLACEMENT_RIGHT = 'right';
facets: Dict<Facet>;
issues: Issue[];
loading: boolean;
- loadingRule: boolean;
loadingFacets: Dict<boolean>;
loadingMore: boolean;
+ loadingRule: boolean;
locationsNavigator: boolean;
myIssues: boolean;
openFacets: Dict<boolean>;
- showVariantsFilter: boolean;
openIssue?: Issue;
openPopup?: { issue: string; name: string };
openRuleDetails?: RuleDetails;
selected?: string;
selectedFlowIndex?: number;
selectedLocationIndex?: number;
+ showVariantsFilter: boolean;
}
// When opening a specific issue, number of issues to fetch through pagination before loading it specifically
} from '../../../types/types';
export interface SnippetViewerProps {
+ className?: string;
component: SourceViewerFile;
displayLineNumberOptions?: boolean;
displaySCM?: boolean;
duplicationsByLine?: { [line: number]: number[] };
expandBlock: (snippetIndex: number, direction: ExpandDirection) => Promise<void>;
handleSymbolClick: (symbols: string[]) => void;
+ hideLocationIndex?: boolean;
highlightedLocationMessage: { index: number; text: string | undefined } | undefined;
highlightedSymbols: string[];
index: number;
renderAdditionalChildInLine?: (line: SourceLine) => React.ReactNode | undefined;
renderDuplicationPopup: (index: number, line: number) => React.ReactNode;
snippet: SourceLine[];
- className?: string;
snippetSourcesMap?: LineMap;
- hideLocationIndex?: boolean;
}
type Props = SnippetViewerProps & ThemeProp;
const startIndex = Math.max(1, loc.textRange.startLine - LINES_ABOVE);
const endIndex = addLinesBellow({ issue, locationEnd: loc.textRange.endLine });
- let firstCollision: { start: number; end: number } | undefined;
+ let firstCollision: { end: number; start: number } | undefined;
// Remove ranges that collide into the first collision
snippets = snippets.filter((snippet) => {
export interface ConciseIssueProps {
issue: Issue;
+ onClick: (issueKey: string) => void;
onFlowSelect: (index?: number) => void;
onLocationSelect: (index: number) => void;
- onClick: (issueKey: string) => void;
selected: boolean;
selectedFlowIndex: number | undefined;
selectedLocationIndex: number | undefined;
onToggle: (property: string) => void;
open: boolean;
query: Query;
- stats: Dict<number> | undefined;
referencedUsers: Dict<UserBase>;
+ stats: Dict<number> | undefined;
}
export class AssigneeFacet extends React.PureComponent<Props> {
createdBefore: Date | undefined;
createdInLast: string;
fetching: boolean;
+ inNewCodePeriod: boolean;
onChange: (changes: Partial<Query>) => void;
onToggle: (property: string) => void;
open: boolean;
- inNewCodePeriod: boolean;
stats: Dict<number> | undefined;
}
export type FacetItemsListProps =
| {
children?: React.ReactNode;
- labelledby: string;
label?: never;
+ labelledby: string;
}
| {
children?: React.ReactNode;
- labelledby?: never;
label: string;
+ labelledby?: never;
};
export function FacetItemsList({ children, labelledby, label }: FacetItemsListProps) {
import { ListStyleFacet } from './ListStyleFacet';
interface Props {
+ disabled?: boolean;
+ disabledHelper?: string;
fetching?: boolean;
languages: Languages;
- maxInitialItems?: number;
- selectedLanguages: string[];
loadSearchResultCount?: (property: string, changes: Partial<Query>) => Promise<Facet>;
+ maxInitialItems?: number;
onChange: (changes: Partial<Query>) => void;
onToggle: (property: string) => void;
open: boolean;
query?: Query;
referencedLanguages?: Dict<ReferencedLanguage>;
+ selectedLanguages: string[];
stats: Dict<number> | undefined;
- disabled?: boolean;
- disabledHelper?: string;
}
class LanguageFacetClass extends React.PureComponent<Props> {
interface SearchResponse<S> {
maxResults?: boolean;
- results: S[];
paging?: Paging;
+ results: S[];
}
export interface Props<S> {
+ disableZero?: boolean;
disabled?: boolean;
disabledHelper?: string;
- disableZero?: boolean;
facetHeader: string;
fetching: boolean;
getFacetItemText: (item: string) => string;
query?: RawQuery;
renderFacetItem: (item: string) => string | JSX.Element;
renderSearchResult: (result: S, query: string) => React.ReactNode;
+ searchInputAriaLabel?: string;
searchPlaceholder: string;
showLessAriaLabel?: string;
showMoreAriaLabel?: string;
- searchInputAriaLabel?: string;
showStatBar?: boolean;
stats: Dict<number> | undefined;
values: string[];
interface State<S> {
autoFocus: boolean;
query: string;
- searching: boolean;
searchMaxResults?: boolean;
searchPaging?: Paging;
searchResults?: S[];
searchResultsCounts: Dict<number>;
+ searching: boolean;
showFullList: boolean;
}
import { FacetItemsList } from './FacetItemsList';
export interface PeriodFilterProps {
- onChange: (changes: Partial<Query>) => void;
newCodeSelected: boolean;
+ onChange: (changes: Partial<Query>) => void;
}
enum Period {
onChange: (changes: Partial<Query>) => void;
onToggle: (property: string) => void;
open: boolean;
- value: true | undefined;
stats: Dict<number> | undefined;
+ value: true | undefined;
}
export function PrioritizedRuleFacet(props: Readonly<PrioritizedRuleFacetProps>) {
interface Props {
component: Component | undefined;
- loadSearchResultCount: (property: string, changes: Partial<Query>) => Promise<Facet>;
fetching: boolean;
+ loadSearchResultCount: (property: string, changes: Partial<Query>) => Promise<Facet>;
onChange: (changes: Partial<Query>) => void;
onToggle: (property: string) => void;
open: boolean;
const handleSearch = (
query: string,
page = 1,
- ): Promise<{ results: SearchedProject[]; paging: Paging }> => {
+ ): Promise<{ paging: Paging; results: SearchedProject[] }> => {
if (
component &&
[
onFacetToggle: (property: string) => void;
onFilterChange: (changes: Partial<Query>) => void;
openFacets: Dict<boolean>;
- showVariantsFilter: boolean;
query: Query;
referencedComponentsById: Dict<ReferencedComponent>;
referencedComponentsByKey: Dict<ReferencedComponent>;
referencedLanguages: Dict<ReferencedLanguage>;
referencedRules: Dict<ReferencedRule>;
referencedUsers: Dict<UserBase>;
+ showVariantsFilter: boolean;
}
export function Sidebar(props: Readonly<Props>) {
export interface CommonProps {
fetching: boolean;
- needIssueSync?: boolean;
help?: React.ReactNode;
+ needIssueSync?: boolean;
onChange: (changes: Partial<Query>) => void;
onToggle: (property: string) => void;
open: boolean;
}
interface Props<T = string> extends CommonProps {
- property: string;
- listItems: Array<T>;
itemNamePrefix: string;
- selectedItems: Array<T>;
+ listItems: Array<T>;
+ property: string;
renderIcon?: (item: string, disabled: boolean) => React.ReactNode;
+ selectedItems: Array<T>;
}
export function SimpleListStyleFacet(props: Props) {
onToggle: (property: string) => void;
open: boolean;
owaspTop10: string[];
- owaspTop10Open: boolean;
- owaspTop10Stats: Dict<number> | undefined;
'owaspTop10-2021': string[];
'owaspTop10-2021Open': boolean;
'owaspTop10-2021Stats': Dict<number> | undefined;
+ owaspTop10Open: boolean;
+ owaspTop10Stats: Dict<number> | undefined;
query: Partial<Query>;
sonarsourceSecurity: string[];
sonarsourceSecurityOpen: boolean;
}
interface State {
- standards: Standards;
showFullSonarSourceList: boolean;
+ standards: Standards;
}
type StatsProp =
import { ListStyleFacet } from './ListStyleFacet';
interface Props {
- component: Component | undefined;
branch?: string;
+ component: Component | undefined;
fetching: boolean;
loadSearchResultCount: (property: string, changes: Partial<Query>) => Promise<Facet>;
onChange: (changes: Partial<Query>) => void;
const OWASP_ASVS_4_0 = 'owaspAsvs-4.0';
export interface Query {
+ [OWASP_ASVS_4_0]: string[];
assigned: boolean;
assignees: string[];
author: string[];
fixedInPullRequest: string;
impactSeverities: SoftwareImpactSeverity[];
impactSoftwareQualities: SoftwareQuality[];
+ inNewCodePeriod: boolean;
+ issueStatuses: IssueStatus[];
issues: string[];
languages: string[];
+ owaspAsvsLevel: string;
owaspTop10: string[];
'owaspTop10-2021': string[];
'pciDss-3.2': string[];
'pciDss-4.0': string[];
- [OWASP_ASVS_4_0]: string[];
- owaspAsvsLevel: string;
+ prioritizedRule?: boolean;
projects: string[];
+ resolved?: boolean;
rules: string[];
scopes: string[];
severities: string[];
- inNewCodePeriod: boolean;
sonarsourceSecurity: string[];
sort: string;
- issueStatuses: IssueStatus[];
tags: string[];
types: string[];
- resolved?: boolean;
- prioritizedRule?: boolean;
}
export const STANDARDS = 'standards';
interface State {
message?: string;
- startedAt?: string;
migrationState?: MigrationStatus;
- systemStatus?: string;
- wasStarting?: boolean;
progress?: {
completedSteps: number;
- totalSteps: number;
expectedFinishTimestamp: string;
+ totalSteps: number;
};
+ startedAt?: string;
+ systemStatus?: string;
+ wasStarting?: boolean;
}
const DELAY_REDIRECT_PREV_PAGE = 2500;
interface Props {
progress: {
completedSteps: number;
- totalSteps: number;
expectedFinishTimestamp: string;
+ totalSteps: number;
};
}
interface Props {
currentEdition?: EditionKey;
fetchPendingPlugins: () => void;
- pendingPlugins: PendingPluginResult;
location: Location;
+ pendingPlugins: PendingPluginResult;
router: Router;
standaloneMode?: boolean;
updateCenterActive: boolean;
}
interface State {
- serverId?: string;
ncloc?: number;
+ serverId?: string;
}
export default class EditionBoxes extends React.PureComponent<Props, State> {
import App from './App';
export interface MarketplaceAppContainerProps {
- location: Location;
appState: AppState;
+ location: Location;
}
function MarketplaceAppContainer(props: MarketplaceAppContainerProps) {
import PluginInstalled from './components/PluginInstalled';
export interface PluginsListProps {
- plugins: Plugin[];
pending: {
installing: PendingPlugin[];
- updating: PendingPlugin[];
removing: PendingPlugin[];
+ updating: PendingPlugin[];
};
+ plugins: Plugin[];
readOnly: boolean;
refreshPending: () => void;
}
interface Props {
pluginName: string;
- update: Update;
release: Release;
+ update: Update;
}
export default function PluginUpdateItem({ release, update, pluginName }: Readonly<Props>) {
import { HomePage } from '../../../types/users';
interface Props {
- component: Component;
branch: Branch;
+ component: Component;
measures: MeasureEnhanced[];
showTakeTheTourButton: boolean;
startTour?: () => void;
import { MeasurementType, getMeasurementMetricKey } from '../utils';
interface Props {
- useDiffMetric?: boolean;
branch?: BranchLike;
component: Component;
- measures: MeasureEnhanced[];
conditions: QualityGateStatusConditionEnhanced[];
+ measures: MeasureEnhanced[];
+ useDiffMetric?: boolean;
}
/**
export interface QualityGateConditionsProps {
branchLike?: BranchLike;
- component: Pick<Component, 'key'>;
collapsible?: boolean;
+ component: Pick<Component, 'key'>;
failedConditions: QualityGateStatusConditionEnhanced[];
isBuiltInQualityGate?: boolean;
}
import { translate } from '../../../helpers/l10n';
interface Props {
- status: Status;
failedConditionCount: number;
+ status: Status;
}
export default function QualityGateStatusHeader(props: Props) {
import { Component } from '../../../types/types';
export interface SoftwareImpactMeasureBreakdownCardProps {
- softwareQuality: SoftwareQuality;
+ active?: boolean;
branch?: Branch;
component: Component;
- value?: string;
severity: SoftwareImpactSeverity;
- active?: boolean;
+ softwareQuality: SoftwareQuality;
+ value?: string;
}
export function SoftwareImpactMeasureBreakdownCard(
import SoftwareImpactMeasureRating from './SoftwareImpactMeasureRating';
export interface SoftwareImpactBreakdownCardProps {
+ branch?: Branch;
component: Component;
conditions: QualityGateStatusConditionEnhanced[];
- softwareQuality: SoftwareQuality;
- ratingMetricKey: MetricKey;
measures: MeasureEnhanced[];
- branch?: Branch;
+ ratingMetricKey: MetricKey;
+ softwareQuality: SoftwareQuality;
}
export function SoftwareImpactMeasureCard(props: Readonly<SoftwareImpactBreakdownCardProps>) {
analyses?: Analysis[];
appLeak?: ApplicationPeriod;
component: Component;
+ isNewCode: boolean;
loading?: boolean;
+ onTabSelect: (tab: CodeScope) => void;
period?: Period;
qgStatuses?: QualityGateStatus[];
- isNewCode: boolean;
- onTabSelect: (tab: CodeScope) => void;
}
const SQ_UPGRADE_NOTIFICATION_TIMEOUT = { weeks: 3 };
import { localizeMetric } from '../../../helpers/measures';
interface IssueMeasuresCardInnerProps extends React.HTMLAttributes<HTMLDivElement> {
- metric: MetricKey;
- value?: string;
- header: React.ReactNode;
- url: Partial<Path>;
- failed?: boolean;
- icon?: React.ReactNode;
disabled?: boolean;
+ failed?: boolean;
footer?: React.ReactNode;
+ header: React.ReactNode;
+ icon?: React.ReactNode;
+ metric: MetricKey;
+ url: Partial<Path>;
+ value?: string;
}
export function IssueMeasuresCardInner(props: Readonly<IssueMeasuresCardInnerProps>) {
import { localizeMetric } from '../../../helpers/measures';
export interface MeasuresCardProps {
- url: To;
- value?: string;
- metric: MetricKey;
- label: string;
failed?: boolean;
icon?: React.ReactElement;
+ label: string;
+ metric: MetricKey;
+ url: To;
+ value?: string;
}
export default function MeasuresCard(
import MeasuresCard, { MeasuresCardProps } from './MeasuresCard';
interface Props extends MeasuresCardProps {
+ conditionMetric: MetricKey;
conditions: QualityGateStatusConditionEnhanced[];
label: string;
+ showRequired?: boolean;
url: To;
value?: string;
- conditionMetric: MetricKey;
- showRequired?: boolean;
}
export default function MeasuresCardNumber(
import MeasuresCard from './MeasuresCard';
interface Props {
- componentKey: string;
branchLike?: BranchLike;
- measurementType: MeasurementType;
- label: string;
- url: To;
- measures: MeasureEnhanced[];
- conditions: QualityGateStatusConditionEnhanced[];
+ componentKey: string;
conditionMetric: MetricKey;
+ conditions: QualityGateStatusConditionEnhanced[];
+ label: string;
linesMetric: MetricKey;
+ measurementType: MeasurementType;
+ measures: MeasureEnhanced[];
overallConditionMetric?: MetricKey;
- useDiffMetric?: boolean;
showRequired?: boolean;
+ url: To;
+ useDiffMetric?: boolean;
}
export default function MeasuresCardPercent(
import BranchQualityGateConditions from './BranchQualityGateConditions';
interface Props {
- status: Status;
branchLike?: BranchLike;
component: Pick<Component, 'key'>;
failedConditions: QualityGateStatusConditionEnhanced[];
+ status: Status;
}
export default function BranchQualityGate(props: Readonly<Props>) {
import { Status, getConditionRequiredLabel } from '../utils';
interface Props {
+ component: Component;
conditions: QualityGateStatusConditionEnhanced[];
measures: MeasureEnhanced[];
- component: Component;
pullRequest: PullRequest;
}
interface Props {
className?: string;
- pullRequest: PullRequest;
component: Component;
- measures: MeasureEnhanced[];
conditions: QualityGateStatusConditionEnhanced[];
+ measures: MeasureEnhanced[];
+ pullRequest: PullRequest;
}
export default function MeasuresCardPanel(props: React.PropsWithChildren<Props>) {
import LastAnalysisLabel from '../components/LastAnalysisLabel';
interface Props {
- pullRequest: PullRequest;
measures: MeasureEnhanced[];
+ pullRequest: PullRequest;
}
export default function PullRequestMetaTopBar({ pullRequest, measures }: Readonly<Props>) {
import SonarLintAd from './SonarLintAd';
interface Props {
- pullRequest: PullRequest;
component: Component;
+ pullRequest: PullRequest;
}
export default function PullRequestOverview(props: Readonly<Readonly<Props>>) {
interface Props {
permission: {
+ groupsCount: number;
key: string;
usersCount: number;
- groupsCount: number;
withProjectCreator?: boolean;
};
}
import Template from './Template';
interface Props {
- location: Location;
appState: AppState;
+ location: Location;
}
interface State {
- ready: boolean;
- permissions: Permission[];
permissionTemplates: PermissionTemplate[];
+ permissions: Permission[];
+ ready: boolean;
}
class PermissionTemplatesApp extends React.PureComponent<Props, State> {
})
: Promise.resolve({ paging: undefined, users: [] });
- const getGroups: Promise<{ paging?: Paging; groups: PermissionGroup[] }> =
+ const getGroups: Promise<{ groups: PermissionGroup[]; paging?: Paging }> =
filter !== 'users'
? api.getPermissionTemplateGroups({
templateId: template.id,
export function mergeDefaultsToTemplates(
permissionTemplates: PermissionTemplate[],
- defaultTemplates: Array<{ templateId: string; qualifier: string }> = [],
+ defaultTemplates: Array<{ qualifier: string; templateId: string }> = [],
): PermissionTemplate[] {
return permissionTemplates.map((permissionTemplate) => {
const defaultFor: string[] = [];
})
: Promise.resolve({ paging: undefined, users: [] });
- const getGroups: Promise<{ paging?: Paging; groups: PermissionGroup[] }> =
+ const getGroups: Promise<{ groups: PermissionGroup[]; paging?: Paging }> =
filter !== 'users'
? api.getGlobalPermissionsGroups({
q: query || undefined,
})
: Promise.resolve({ paging: undefined, users: [] });
- const getGroups: Promise<{ paging?: Paging; groups: PermissionGroup[] }> =
+ const getGroups: Promise<{ groups: PermissionGroup[]; paging?: Paging }> =
filter !== 'users'
? api.getPermissionsGroupsForComponent({
projectKey: component.key,
canDeleteAnalyses?: boolean;
initializing: boolean;
leakPeriodDate?: Date;
+ onUpdateQuery: (changes: Partial<Query>) => void;
project: { qualifier: string };
query: Query;
- onUpdateQuery: (changes: Partial<Query>) => void;
}
const LIST_MARGIN_TOP = 24;
};
getNewCodePeriodStartKey(versionByDay: AnalysesByDay[]): {
- firstNewCodeAnalysisKey: string | undefined;
baselineAnalysisKey: string | undefined;
+ firstNewCodeAnalysisKey: string | undefined;
} {
const { leakPeriodDate } = this.props;
if (!leakPeriodDate) {
export interface ProjectActivityAnalysisProps extends WrappedComponentProps {
analysis: ParsedAnalysis;
canAdmin?: boolean;
- canDeleteAnalyses?: boolean;
canCreateVersion: boolean;
+ canDeleteAnalyses?: boolean;
isBaseline: boolean;
isFirst: boolean;
- selected: boolean;
onUpdateSelectedDate: (date: Date) => void;
+ selected: boolean;
}
export enum Dialog {
export interface State {
analyses: ParsedAnalysis[];
analysesLoading: boolean;
- leakPeriodDate?: Date;
graphLoading: boolean;
initialized: boolean;
+ leakPeriodDate?: Date;
measuresHistory: MeasureHistory[];
query: Query;
}
analyses: ParsedAnalysis[];
analysesLoading: boolean;
graphLoading: boolean;
- leakPeriodDate?: Date;
initializing: boolean;
- project: Pick<Component, 'configuration' | 'key' | 'leakPeriodDate' | 'qualifier'>;
- metrics: Metric[];
+ leakPeriodDate?: Date;
measuresHistory: MeasureHistory[];
- query: Query;
+ metrics: Metric[];
onUpdateQuery: (changes: Partial<Query>) => void;
+ project: Pick<Component, 'configuration' | 'key' | 'leakPeriodDate' | 'qualifier'>;
+ query: Query;
}
export default function ProjectActivityAppRenderer(props: Props) {
interface Props {
from?: Date;
- to?: Date;
onChange: (changes: Partial<Query>) => void;
+ to?: Date;
}
export default class ProjectActivityDateInput extends React.PureComponent<Props> {
}
interface State {
- graphStartDate?: Date;
graphEndDate?: Date;
- series: Serie[];
+ graphStartDate?: Date;
graphs: Serie[][];
+ series: Serie[];
}
const MAX_GRAPH_NB = 2;
import { ParsedAnalysis } from '../../../../types/project-activity';
interface Props {
- category?: string;
addEventButtonText: string;
analysis: ParsedAnalysis;
+ category?: string;
onClose: () => void;
}
analysisKey: string;
event: AnalysisEvent;
header: string;
- removeEventQuestion: string;
onClose: () => void;
+ removeEventQuestion: string;
}
export default function RemoveEventForm(props: RemoveEventFormProps) {
export interface AnalysesByDay {
byDay: Dict<ParsedAnalysis[]>;
- version: string | null;
key: string | null;
+ version: string | null;
}
export function getAnalysesByVersionByDay(
branchLike?: BranchLike;
component: Component;
currentUser: CurrentUser;
- onComponentChange: (changes: {}) => void;
metrics: Dict<Metric>;
+ onComponentChange: (changes: {}) => void;
}
function ProjectInformationApp(props: Props) {
}
interface ProjectInformationSectionProps {
- last?: boolean;
className?: string;
+ last?: boolean;
}
function ProjectInformationSection(props: PropsWithChildren<ProjectInformationSectionProps>) {
languages,
deprecatedByKey,
}: {
- profile: ComponentQualityProfile;
- languages: Languages;
deprecatedByKey: Dict<number>;
+ languages: Languages;
+ profile: ComponentQualityProfile;
}) {
const languageFromStore = languages[profile.language];
const languageName = languageFromStore ? languageFromStore.name : profile.language;
export interface BadgeOptions {
branch?: string;
format?: BadgeFormats;
- project?: string;
metric?: string;
+ project?: string;
pullRequest?: string;
}
import { Component } from '../../../types/types';
interface Props {
- component: Pick<Component, 'key' | 'name'>;
branchLike?: BranchLike;
+ component: Pick<Component, 'key' | 'name'>;
}
export default function RegulatoryReport({ component, branchLike }: Props) {
interface Props {
branchList: Branch[];
component: Component;
- inheritedSetting: NewCodeDefinition;
globalNewCodeDefinition: NewCodeDefinition;
+ inheritedSetting: NewCodeDefinition;
}
interface State {
branch: BranchWithNewCodePeriod;
branchList: Branch[];
component: string;
- onClose: (branch?: string, newSetting?: NewCodeDefinition) => void;
- inheritedSetting: NewCodeDefinition;
globalNewCodeDefinition: NewCodeDefinition;
+ inheritedSetting: NewCodeDefinition;
+ onClose: (branch?: string, newSetting?: NewCodeDefinition) => void;
}
interface State {
import { Analysis } from '../../../types/project-activity';
export interface Props {
- onSelect: (selection: NewCodeDefinitionType) => void;
- selected: boolean;
analysis: string;
branch: string;
component: string;
+ onSelect: (selection: NewCodeDefinitionType) => void;
+ selected: boolean;
}
export default function NewCodeDefinitionSettingAnalysis({
branchList: BranchOption[];
className?: string;
disabled?: boolean;
+ inputSelectMenuPlacement?: MenuPlacement;
onChangeReferenceBranch: (value: string) => void;
onSelect: (selection: NewCodeDefinitionType) => void;
referenceBranch: string;
NewCodeDefinitionLevels,
NewCodeDefinitionLevels.NewProject | NewCodeDefinitionLevels.Global
>;
- inputSelectMenuPlacement?: MenuPlacement;
}
export interface BranchOption {
import ProjectNewCodeDefinitionSelector from './ProjectNewCodeDefinitionSelector';
interface ProjectNewCodeDefinitionAppProps extends WithAvailableFeaturesProps {
+ appState: AppState;
branchLike: Branch;
branchLikes: BranchLike[];
component: Component;
- appState: AppState;
}
function ProjectNewCodeDefinitionApp(props: Readonly<ProjectNewCodeDefinitionAppProps>) {
export interface ProjectBaselineSelectorProps {
analysis?: string;
branch?: Branch;
- branchesEnabled?: boolean;
branchList: Branch[];
+ branchesEnabled?: boolean;
component: string;
days: string;
globalNewCodeDefinition: NewCodeDefinition;
export function AddLanguageModal(props: AddLanguageModalProps) {
const { languages, profilesByLanguage, unavailableLanguages } = props;
- const [{ language, key }, setSelected] = React.useState<{ language?: string; key?: string }>({
+ const [{ language, key }, setSelected] = React.useState<{ key?: string; language?: string }>({
language: undefined,
key: undefined,
});
import { getQualityProfileUrl } from '../../../helpers/urls';
export interface ProfileOption extends LabelValueSelectOption {
- language: string;
isDisabled: boolean;
+ language: string;
}
export type LanguageProfileSelectOptionProps = OptionProps<ProfileOption, false>;
projects: components.map(
(
component: Component & {
- measures: { languages?: string; new_coverage?: string };
isScannable: boolean;
+ measures: { languages?: string; new_coverage?: string };
},
) => {
// eslint-disable-next-line jest/no-conditional-in-test
handlePerspectiveChange = ({ view }: { view?: string }) => {
const query: {
- view: string | undefined;
sort?: string;
+ view: string | undefined;
} = {
view: view === 'overall' ? undefined : view,
};
}
export interface PerspectiveOption {
- value: string;
label: string;
+ value: string;
}
export default class PerspectiveSelect extends React.PureComponent<Props> {
handleFavorite: (component: string, isFavorite: boolean) => void;
isFavorite: boolean;
isFiltered: boolean;
- loading: boolean;
loadMore: () => void;
+ loading: boolean;
projects: Project[];
query: Query;
total?: number;
}
export interface Option {
- label: string;
- value: string;
className?: string;
+ label: string;
short?: string;
+ value: string;
}
export default class ProjectsSortingSelect extends React.PureComponent<Props> {
path = '/projects',
currentUser = mockLoggedInUser(),
}: {
- path?: string;
currentUser?: CurrentUser;
+ path?: string;
} = {}) {
return render(
<MemoryRouter initialEntries={[path]}>
import * as React from 'react';
export interface ProjectCardMeasureProps {
+ className?: string;
label: string;
metricKey: string;
- className?: string;
}
export default function ProjectCardMeasure(
import ProjectCardMeasure from './ProjectCardMeasure';
export interface ProjectCardMeasuresProps {
+ componentQualifier: ComponentQualifier;
isNewCode: boolean;
measures: Dict<string | undefined>;
- componentQualifier: ComponentQualifier;
}
function renderNewIssues(props: ProjectCardMeasuresProps) {
export type Option = string | number;
interface Props {
- property: string;
className?: string;
- onQueryChange: (change: RawQuery) => void;
- options: Option[];
- renderAccessibleLabel: (option: Option) => string;
- renderOption: (option: Option, isSelected: boolean) => React.ReactNode;
-
- value?: Option;
facet?: Facet;
+ getFacetValueForOption?: (facet: Facet, option: Option) => number;
+ header: string;
+ highlightUnder?: number;
+ highlightUnderMax?: number;
+
maxFacetValue?: number;
+ onQueryChange: (change: RawQuery) => void;
optionClassName?: string;
+ options: Option[];
- getFacetValueForOption?: (facet: Facet, option: Option) => number;
+ property: string;
- highlightUnder?: number;
- highlightUnderMax?: number;
+ renderAccessibleLabel: (option: Option) => string;
+ renderOption: (option: Option, isSelected: boolean) => React.ReactNode;
- header: string;
+ value?: Option;
}
const defaultGetFacetValueForOption = (facet: Facet, option: string | number) => facet[option];
type Level = 'ERROR' | 'WARN' | 'OK';
export interface Query {
+ [x: string]: string | number | string[] | undefined;
+ coverage?: number;
+ duplications?: number;
gate?: Level;
- reliability?: number;
- new_reliability?: number;
- security?: number;
- new_security?: number;
- security_review_rating?: number;
- new_security_review_rating?: number;
+ languages?: string[];
maintainability?: number;
- new_maintainability?: number;
- coverage?: number;
new_coverage?: number;
- duplications?: number;
new_duplications?: number;
- size?: number;
new_lines?: number;
- languages?: string[];
+ new_maintainability?: number;
+ new_reliability?: number;
+ new_security?: number;
+ new_security_review_rating?: number;
qualifier?: ComponentQualifier;
- tags?: string[];
+ reliability?: number;
search?: string;
+ security?: number;
+ security_review_rating?: number;
+ size?: number;
sort?: string;
+ tags?: string[];
view?: string;
- [x: string]: string | number | string[] | undefined;
}
export function parseUrlQuery(urlQuery: RawQuery): Query {
export interface Project {
analysisDate?: string;
isFavorite?: boolean;
+ isScannable: boolean;
key: string;
leakPeriodDate?: string;
measures: Dict<string>;
qualifier: ComponentQualifier;
tags: string[];
visibility: Visibility;
- isScannable: boolean;
}
export interface Facet {
return translate('projects.sort', sort ?? 'name');
}
-export function parseSorting(sort: string): { sortValue: string; sortDesc: boolean } {
+export function parseSorting(sort: string): { sortDesc: boolean; sortValue: string } {
const desc = sort.startsWith('-');
return { sortValue: desc ? sort.substring(1) : sort, sortDesc: desc };
query,
pageIndex = 1,
}: {
- query: Query;
isFavorite: boolean;
pageIndex?: number;
+ query: Query;
}) {
const ps = PAGE_SIZE;
return getMeasuresForProjects(projectKeys, metrics);
}
-function mapFacetValues(values: Array<{ val: string; count: number }>) {
+function mapFacetValues(values: Array<{ count: number; val: string }>) {
const map: Dict<number> = {};
values.forEach((value) => {
return map;
}
-export function convertToSorting({ sort }: Query): { s?: string; asc?: boolean } {
+export function convertToSorting({ sort }: Query): { asc?: boolean; s?: string } {
if (sort?.startsWith('-')) {
return { s: propertyToMetricMap[sort.substring(1)], asc: false };
}
const ONE_MONTH = 30 * ONE_DAY;
const ONE_YEAR = 12 * ONE_MONTH;
-function format(periods: Array<{ value: number; label: string }>) {
+function format(periods: Array<{ label: string; value: number }>) {
let result = '';
let count = 0;
let lastId = -1;
export interface Props {
analyzedBefore: Date | undefined;
+ appState: AppState;
onAllDeselected: () => void;
onAllSelected: () => void;
onDateChanged: (analyzedBefore: Date | undefined) => void;
onDeleteProjects: () => void;
onProvisionedChanged: (provisioned: boolean) => void;
onQualifierChanged: (qualifier: string) => void;
- onVisibilityChanged: (qualifier: string) => void;
onSearch: (query: string) => void;
+ onVisibilityChanged: (qualifier: string) => void;
projects: Project[];
provisioned: boolean;
qualifiers: string;
query: string;
ready: boolean;
selection: any[];
- appState: AppState;
total: number;
visibility?: Visibility;
}
import { translate } from '../../../helpers/l10n';
interface Props {
- renderCaycModal: ({ onClose }: { onClose: () => void }) => React.ReactNode;
isOptimizing?: boolean;
+ renderCaycModal: ({ onClose }: { onClose: () => void }) => React.ReactNode;
}
export default function CaycNonCompliantBanner({ renderCaycModal, isOptimizing }: Readonly<Props>) {
}
interface Props {
- condition: ConditionType;
canEdit: boolean;
+ condition: ConditionType;
+ isCaycModal?: boolean;
metric: Metric;
qualityGate: QualityGate;
showEdit?: boolean;
- isCaycModal?: boolean;
}
export default function ConditionComponent({
interface Props {
canEdit: boolean;
- metrics: Dict<Metric>;
conditions: Condition[];
- scope: 'new' | 'overall' | 'new-cayc';
- onClose: () => void;
+ isOptimizing?: boolean;
lockEditing: () => void;
+ metrics: Dict<Metric>;
+ onClose: () => void;
qualityGate: QualityGate;
- isOptimizing?: boolean;
+ scope: 'new' | 'overall' | 'new-cayc';
}
export default function CaycReviewUpdateConditionsModal(props: Readonly<Props>) {
interface Props {
condition: Condition;
+ isCaycCompliantAndOverCompliant?: boolean;
isCaycModal?: boolean;
metric: Metric;
- isCaycCompliantAndOverCompliant?: boolean;
}
function ConditionValue({
interface Props {
condition: Condition;
- metric: Metric;
isToBeModified?: boolean;
+ metric: Metric;
}
export default function ConditionValueDescription({
import QGRecommendedIcon from './QGRecommendedIcon';
interface Props {
- qualityGate: QualityGate;
isFetching?: boolean;
+ qualityGate: QualityGate;
}
const FORBIDDEN_METRIC_TYPES = ['DATA', 'DISTRIB', 'STRING', 'BOOL'];
interface Props {
canEdit: boolean;
+ conditions: ConditionType[];
+ isCaycModal?: boolean;
metrics: Dict<Metric>;
qualityGate: QualityGate;
- conditions: ConditionType[];
scope: 'new' | 'overall' | 'new-cayc';
showEdit?: boolean;
- isCaycModal?: boolean;
}
function Header() {
import QualityGatePermissions from './QualityGatePermissions';
export interface DetailsContentProps {
- qualityGate: QualityGate;
isFetching?: boolean;
+ qualityGate: QualityGate;
}
export function DetailsContent(props: DetailsContentProps) {
interface Props {
condition: Condition;
- metric: Metric;
header: string;
+ metric: Metric;
onClose: () => void;
qualityGate: QualityGate;
}
import QGRecommendedIcon from './QGRecommendedIcon';
interface Props {
- qualityGates: QualityGate[];
currentQualityGate?: string;
+ qualityGates: QualityGate[];
}
export default function List({ qualityGates, currentQualityGate }: Props) {
interface Props {
metric?: Metric;
- metricsArray: Metric[];
metrics: Dict<Metric>;
+ metricsArray: Metric[];
onMetricChange: (metric: Metric) => void;
}
import { UserBase } from '../../../types/users';
export interface PermissionItemProps {
- onClickDelete: (item: UserBase | Group) => void;
item: UserBase | Group;
+ onClickDelete: (item: UserBase | Group) => void;
}
export default function PermissionItem(props: PermissionItemProps) {
}
interface State {
- needToReload: boolean;
lastSearchParams?: SelectListSearchParams;
+ needToReload: boolean;
projects: Project[];
projectsTotalCount?: number;
selectedProjects: string[];
interface State {
groups: Group[];
- submitting: boolean;
loading: boolean;
- showAddModal: boolean;
permissionToDelete?: UserBase | Group;
+ showAddModal: boolean;
+ submitting: boolean;
users: UserBase[];
}
import { UserBase } from '../../../types/users';
export interface QualityGatePermissionsAddModalRendererProps {
- onClose: () => void;
handleSearch: (
q: string,
resolve: (options: Options<LabelValueSelectOption<UserBase | UserGroup>>) => void,
) => void;
+ onClose: () => void;
onSelection: (selection: SingleValue<LabelValueSelectOption<UserBase | UserGroup>>) => void;
- selection?: UserBase | UserGroup;
onSubmit: (event: React.SyntheticEvent<HTMLFormElement>) => void;
+ selection?: UserBase | UserGroup;
submitting: boolean;
}
groups: Group[];
loading: boolean;
onClickAddPermission: () => void;
+ onClickDeletePermission: (item: UserBase | Group) => void;
onCloseAddPermission: () => void;
- onSubmitAddPermission: (item: UserBase | Group) => void;
onCloseDeletePermission: () => void;
onConfirmDeletePermission: (item: UserBase | Group) => void;
- onClickDeletePermission: (item: UserBase | Group) => void;
+ onSubmitAddPermission: (item: UserBase | Group) => void;
permissionToDelete?: UserBase | Group;
qualityGate: QualityGate;
showAddModal: boolean;
import { Metric } from '../../../types/types';
interface Props {
- name: string;
- value: string;
disabled?: boolean;
metric: Metric;
+ name: string;
onChange: (value: string) => void;
+ value: string;
}
export default class ThresholdInput extends React.PureComponent<Props> {
import { CaycStatus, Condition, Dict, Metric, QualityGate } from '../../types/types';
interface GroupedByMetricConditions {
- overallCodeConditions: Condition[];
- newCodeConditions: Condition[];
caycConditions: Condition[];
+ newCodeConditions: Condition[];
+ overallCodeConditions: Condition[];
}
type CommonCaycMetricKeys =
export function getWeakMissingAndNonCaycConditions(conditions: Condition[]) {
const result: {
- weakConditions: Condition[];
missingConditions: Condition[];
+ weakConditions: Condition[];
} = {
weakConditions: [],
missingConditions: [],
import ChangelogSearch from './ChangelogSearch';
interface Props {
- profile: Profile;
location: Location;
+ profile: Profile;
router: Router;
}
import { CleanCodeAttribute, CleanCodeAttributeCategory } from '../../../types/clean-code-taxonomy';
interface Props {
- oldCleanCodeAttribute: CleanCodeAttribute;
- oldCleanCodeAttributeCategory: CleanCodeAttributeCategory;
newCleanCodeAttribute: CleanCodeAttribute;
newCleanCodeAttributeCategory: CleanCodeAttributeCategory;
+ oldCleanCodeAttribute: CleanCodeAttribute;
+ oldCleanCodeAttributeCategory: CleanCodeAttributeCategory;
}
export default function CleanCodeAttributeChange(props: Readonly<Props>) {
import { Profile } from '../types';
interface Props {
+ onCompare: (rule: string) => void;
profile: Profile;
profiles: Profile[];
- onCompare: (rule: string) => void;
withKey?: string;
}
interface Option {
- value: string;
- label: string;
isDefault: boolean | undefined;
+ label: string;
+ value: string;
}
export default function ComparisonForm(props: Readonly<Props>) {
import Tooltip from '../../../components/controls/Tooltip';
interface Props {
+ canDeactivateInheritedRules: boolean;
onDone: () => Promise<void>;
profile: Profile;
ruleKey: string;
- canDeactivateInheritedRules: boolean;
}
export default function ComparisonResultDeactivation(props: React.PropsWithChildren<Props>) {
type Params = Dict<string>;
interface Props extends CompareResponse {
+ canDeactivateInheritedRules: boolean;
leftProfile: Profile;
refresh: () => Promise<void>;
rightProfile?: Profile;
- canDeactivateInheritedRules: boolean;
}
export default function ComparisonResults(props: Readonly<Props>) {
import { FormattedMessage, useIntl } from 'react-intl';
interface Props {
- profileName: string;
- comparedProfileName?: string;
additionalCount: number;
+ comparedProfileName?: string;
fewerCount: number;
+ profileName: string;
}
export default function ComparisonResultsSummary(props: Readonly<Props>) {
import ProfileModalForm from './ProfileModalForm';
interface Props {
+ isComparable: boolean;
profile: Profile;
router: Router;
- isComparable: boolean;
updateProfiles: () => Promise<void>;
}
import { getProfilePath } from '../utils';
interface Props {
- className?: string;
children?: React.ReactElement<any> | string;
+ className?: string;
language: string;
name: string;
}
interface State {
actions?: Actions;
- loading: boolean;
exporters?: Exporter[];
+ loading: boolean;
profiles?: Profile[];
}
}
interface State {
- needToReload: boolean;
lastSearchParams?: SelectListSearchParams;
+ needToReload: boolean;
projects: ProfileProject[];
projectsTotalCount?: number;
selectedProjects: string[];
} from '../utils';
interface Props {
- profile: Profile;
isComparable: boolean;
+ profile: Profile;
updateProfiles: () => Promise<void>;
}
}
interface ByType {
- val: string;
count: number | null;
+ val: string;
}
export default function ProfileRules({ profile }: Readonly<Props>) {
const [countsBySoftwareImpact, setCountsBySoftwareImpact] = useState<Dict<ByType>>({});
const [totalBySoftwareQuality, setTotalBySoftwareQuality] = useState<Dict<ByType>>({});
const [sonarWayDiff, setSonarWayDiff] = useState<{
+ missingRuleCount: number;
profile: string;
profileName: string;
- missingRuleCount: number;
} | null>(null);
useEffect(() => {
import { RulesFacetName } from '../../../types/rules';
interface Props {
- title: string;
className?: string;
count: number | null;
- qprofile: string;
- total: number | null;
propertyName:
| RulesFacetName.CleanCodeAttributeCategories
| RulesFacetName.ImpactSoftwareQualities;
propertyValue: string;
+ qprofile: string;
+ title: string;
+ total: number | null;
}
export default function ProfileRulesRow(props: Readonly<Props>) {
interface Props {
language: string;
profile: string;
- sonarway: string;
sonarWayMissingRules: number;
+ sonarway: string;
}
export default function ProfileRulesSonarWayComparison(props: Props) {
import { Profile } from '../types';
export interface ProfilesListRowProps {
+ isComparable: boolean;
profile: Profile;
updateProfiles: () => Promise<void>;
- isComparable: boolean;
}
export function ProfilesListRow(props: Readonly<ProfilesListRowProps>) {
import { Dict } from '../../types/types';
export interface Profile extends BaseProfile {
- depth: number;
childrenCount: number;
+ depth: number;
}
export interface Exporter {
key: string;
- name: string;
languages: string[];
+ name: string;
}
export interface ProfileChangelogEventImpactChange {
- oldSoftwareQuality?: SoftwareQuality;
+ newSeverity?: SoftwareImpactSeverity;
newSoftwareQuality?: SoftwareQuality;
oldSeverity?: SoftwareImpactSeverity;
- newSeverity?: SoftwareImpactSeverity;
+ oldSoftwareQuality?: SoftwareQuality;
}
export interface ProfileChangelogEvent {
action: string;
authorName?: string;
cleanCodeAttributeCategory?: CleanCodeAttributeCategory;
+ date: string;
// impacts should be always set in the wild. But Next currently has a specific database state for which this field is undefined. May be possible to make this field required in the future.
impacts?: {
- softwareQuality: SoftwareQuality;
severity: SoftwareImpactSeverity;
+ softwareQuality: SoftwareQuality;
}[];
- date: string;
params?: {
- severity?: IssueSeverity;
- oldCleanCodeAttribute?: CleanCodeAttribute;
- oldCleanCodeAttributeCategory?: CleanCodeAttributeCategory;
+ impactChanges?: ProfileChangelogEventImpactChange[];
newCleanCodeAttribute?: CleanCodeAttribute;
newCleanCodeAttributeCategory?: CleanCodeAttributeCategory;
- impactChanges?: ProfileChangelogEventImpactChange[];
+ oldCleanCodeAttribute?: CleanCodeAttribute;
+ oldCleanCodeAttributeCategory?: CleanCodeAttributeCategory;
+ severity?: IssueSeverity;
} & Dict<string | ProfileChangelogEventImpactChange[] | null>;
ruleKey: string;
ruleName: string;
interface Props {
branchLike?: BranchLike;
- currentUser: CurrentUser;
component: Component;
+ currentUser: CurrentUser;
location: Location;
router: Router;
}
interface State {
- filterByCategory?: { standard: SecurityStandard; category: string };
filterByCWE?: string;
+ filterByCategory?: { category: string; standard: SecurityStandard };
filterByFile?: string;
filters: HotspotFilters;
hotspotKeys?: string[];
filterByFile,
page,
}: {
+ filterByCWE: string | undefined;
+
filterByCategory:
| {
- standard: SecurityStandard;
category: string;
+ standard: SecurityStandard;
}
| undefined;
-
- filterByCWE: string | undefined;
filterByFile: string | undefined;
page: number;
}) {
export interface SecurityHotspotsAppRendererProps {
branchLike?: BranchLike;
component: Component;
+ filterByCWE?: string;
filterByCategory?: {
- standard: SecurityStandard;
category: string;
+ standard: SecurityStandard;
};
- filterByCWE?: string;
filterByFile?: string;
filters: HotspotFilters;
hotspots: RawHotspot[];
import { translate } from '../../../helpers/l10n';
export interface EmptyHotspotsPageProps {
- filtered: boolean;
filterByFile: boolean;
+ filtered: boolean;
isStaticListOfHotspots: boolean;
}
interface HotspotCategoryProps {
expanded: boolean;
- onSetExpanded: (expanded: boolean) => void;
hotspots: RawHotspot[];
isLastAndIncomplete: boolean;
onHotspotClick: (hotspot: RawHotspot) => void;
onLocationClick: (index: number) => void;
+ onSetExpanded: (expanded: boolean) => void;
rating: HotspotRatingEnum;
selectedHotspot: RawHotspot;
selectedHotspotLocation?: number;
import { translate } from '../../../helpers/l10n';
export interface HotspotCommentPopupProps {
- value?: string;
- onSubmit: (comment: string) => void;
onCancel: () => void;
+ onSubmit: (comment: string) => void;
+ value?: string;
}
export default function HotspotCommentModal(props: HotspotCommentPopupProps) {
import Status from './status/Status';
export interface HotspotHeaderProps {
- hotspot: Hotspot;
- component: Component;
branchLike?: BranchLike;
- standards?: Standards;
+ component: Component;
+ hotspot: Hotspot;
onUpdateHotspot: (statusUpdate?: boolean, statusOption?: HotspotStatusOption) => Promise<void>;
+ standards?: Standards;
}
export function HotspotHeader(props: HotspotHeaderProps) {
import Assignee from './Assignee';
interface Props {
- hotspot: Hotspot;
categoryStandard?: string;
+ hotspot: Hotspot;
onUpdateHotspot: (statusUpdate?: boolean, statusOption?: HotspotStatusOption) => Promise<void>;
}
interface HotspotHeaderInfoProps {
children: React.ReactNode;
- title: string;
className?: string;
+ title: string;
}
function HotspotHeaderInfo({ children, title, className }: HotspotHeaderInfoProps) {
interface State {
expandedCategories: Dict<boolean>;
groupedHotspots: Array<{
+ categories: Array<{ hotspots: RawHotspot[]; key: string; title: string }>;
risk: HotspotRatingEnum;
- categories: Array<{ key: string; hotspots: RawHotspot[]; title: string }>;
}>;
}
import { Ide } from '../../../types/sonarlint';
interface Props {
- projectKey: string;
hotspotKey: string;
+ projectKey: string;
}
interface State {
- loading: boolean;
ides: Ide[];
+ loading: boolean;
}
export default class HotspotOpenInIdeButton extends React.PureComponent<Props, State> {
import HotspotListItem from './HotspotListItem';
export interface HotspotSimpleListProps {
+ filterByCWE?: string;
filterByCategory?: {
- standard: SecurityStandard;
category: string;
+ standard: SecurityStandard;
};
- filterByCWE?: string;
filterByFile?: string;
hotspots: RawHotspot[];
hotspotsTotal: number;
loadingMore: boolean;
onHotspotClick: (hotspot: RawHotspot) => void;
- onLocationClick: (index?: number) => void;
onLoadMore: () => void;
+ onLocationClick: (index?: number) => void;
selectedHotspot: RawHotspot;
selectedHotspotLocation?: number;
standards: Standards;
highlightedSymbols: string[];
lastLine?: number;
loading: boolean;
- sourceLines: SourceLine[];
secondaryLocations: FlowLocation[];
+ sourceLines: SourceLine[];
}
const BUFFER_LINES = 10;
hotspot: Hotspot;
loading: boolean;
locations: { [line: number]: LinearIssueLocation[] };
- selectedHotspotLocation?: number;
onExpandBlock: (direction: ExpandDirection) => Promise<void>;
- onSymbolClick: (symbols: string[]) => void;
onLocationSelect: (index: number) => void;
+ onSymbolClick: (symbols: string[]) => void;
+ secondaryLocations: FlowLocation[];
+ selectedHotspotLocation?: number;
sourceLines: SourceLine[];
sourceViewerFile: SourceViewerFile;
- secondaryLocations: FlowLocation[];
}
const noop = () => undefined;
import HotspotOpenInIdeButton from './HotspotOpenInIdeButton';
export interface HotspotSnippetHeaderProps {
- hotspot: Hotspot;
- currentUser: CurrentUser;
- component: Component;
branchLike?: BranchLike;
+ component: Component;
+ currentUser: CurrentUser;
+ hotspot: Hotspot;
}
function HotspotSnippetHeader(props: HotspotSnippetHeaderProps) {
interface Props {
activityTabContent: React.ReactNode;
+ branchLike?: BranchLike;
codeTabContent: React.ReactNode;
+ component: Component;
hotspot: Hotspot;
onUpdateHotspot: (statusUpdate?: boolean, statusOption?: HotspotStatusOption) => Promise<void>;
ruleDescriptionSections?: RuleDescriptionSection[];
ruleLanguage?: string;
- component: Component;
- branchLike?: BranchLike;
}
interface Tab {
);
}
-const StickyTabs = styled.div<{ top: number; isSticky: boolean }>`
+const StickyTabs = styled.div<{ isSticky: boolean; top: number }>`
background-color: ${themeColor('pageBlock')};
box-shadow: ${({ isSticky }) => (isSticky ? themeShadow('sm') : 'none')};
top: ${({ top }) => top}px;
interface Props {
hotspot: Hotspot;
- onStatusOptionChange: (statusOption: HotspotStatusOption) => Promise<void>;
onClose: () => void;
+ onStatusOptionChange: (statusOption: HotspotStatusOption) => Promise<void>;
}
export default function StatusSelection(props: Props) {
import { HotspotStatusOption } from '../../../../types/security-hotspots';
export interface StatusSelectionRendererProps {
- status: HotspotStatusOption;
- onStatusChange: (statusOption: HotspotStatusOption) => void;
comment?: string;
- onCommentChange: (comment: string) => void;
+ loading: boolean;
onCancel: () => void;
+ onCommentChange: (comment: string) => void;
+ onStatusChange: (statusOption: HotspotStatusOption) => void;
onSubmit: () => Promise<void>;
- loading: boolean;
+ status: HotspotStatusOption;
submitDisabled: boolean;
}
import { useEffect, useState } from 'react';
interface Options {
- offset: number;
direction?: 'HORIZONTAL' | 'VERTICAL';
+ offset: number;
}
/*
export interface LoginProps {
identityProviders: IdentityProvider[];
loading: boolean;
+ location: Location;
message?: string;
onSubmit: (login: string, password: string) => Promise<void>;
- location: Location;
}
export default function Login(props: Readonly<LoginProps>) {
export interface AdditionalCategoryComponentProps {
categories: string[];
- definitions: ExtendedSettingDefinition[];
component: Component | undefined;
+ definitions: ExtendedSettingDefinition[];
selectedCategory: string;
}
export interface AdditionalCategory {
- availableGlobally: boolean;
availableForProject: boolean;
+ availableGlobally: boolean;
displayTab: boolean;
key: string;
name: string;
category: string;
component?: Component;
definitions: ExtendedSettingDefinition[];
- subCategory?: string;
displaySubCategoryTitle?: boolean;
noPadding?: boolean;
+ subCategory?: string;
}
interface State {
}
interface State {
+ error?: string;
+ loading: boolean;
+ message: string;
recipient: string;
subject: string;
- message: string;
- loading: boolean;
success?: string;
- error?: string;
}
export class EmailForm extends React.PureComponent<Props, State> {
import PageHeader from './PageHeader';
export interface SettingsAppRendererProps {
- definitions: ExtendedSettingDefinition[];
component?: Component;
+ definitions: ExtendedSettingDefinition[];
loading: boolean;
location: Location;
}
const SEARCH_INPUT_ID = 'settings-search-input';
export interface SettingsSearchRendererProps {
component?: Component;
- results?: ExtendedSettingDefinition[];
- searchQuery: string;
- selectedResult?: string;
- showResults: boolean;
onClickOutside: () => void;
onMouseOverResult: (key: string) => void;
onSearchInputChange: (query: string) => void;
onSearchInputFocus: () => void;
onSearchInputKeyDown: (event: React.KeyboardEvent) => void;
+ results?: ExtendedSettingDefinition[];
+ searchQuery: string;
+ selectedResult?: string;
+ showResults: boolean;
}
export default function SettingsSearchRenderer(props: Readonly<SettingsSearchRendererProps>) {
export interface SubCategoryDefinitionsListProps {
category: string;
component?: Component;
+ displaySubCategoryTitle?: boolean;
location: Location;
+ noPadding?: boolean;
settings: Array<SettingDefinitionAndValue>;
subCategory?: string;
- displaySubCategoryTitle?: boolean;
- noPadding?: boolean;
}
class SubCategoryDefinitionsList extends React.PureComponent<SubCategoryDefinitionsListProps> {
import AlmBindingDefinitionFormRenderer from './AlmBindingDefinitionFormRenderer';
export interface AlmBindingDefinitionFormProps {
+ afterSubmit: (data: AlmBindingDefinitionBase) => void;
alm: AlmKeys;
bindingDefinition?: AlmBindingDefinition;
- onCancel: () => void;
- afterSubmit: (data: AlmBindingDefinitionBase) => void;
enforceValidation?: boolean;
+ onCancel: () => void;
}
interface State {
+ alreadySavedFormData?: AlmBindingDefinition;
+ bitbucketVariant?: AlmKeys.BitbucketServer | AlmKeys.BitbucketCloud;
formData: AlmBindingDefinition;
- touched: boolean;
submitting: boolean;
- bitbucketVariant?: AlmKeys.BitbucketServer | AlmKeys.BitbucketCloud;
- alreadySavedFormData?: AlmBindingDefinition;
+ touched: boolean;
validationError?: string;
}
const BINDING_PER_ALM: {
[key in AlmKeys]: {
createApi: (def: AlmBindingDefinition) => Promise<void>;
- updateApi: (def: AlmBindingDefinition) => Promise<void>;
defaultBinding: AlmBindingDefinition;
optionalFields: Dict<boolean>;
+ updateApi: (def: AlmBindingDefinition) => Promise<void>;
};
} = {
[AlmKeys.Azure]: {
help?: React.ReactNode;
id: string;
isInvalid?: boolean;
+ isSecret?: boolean;
isTextArea?: boolean;
maxLength?: number;
onFieldChange: (id: keyof B, value: string) => void;
overwriteOnly?: boolean;
propKey: keyof B;
value: string;
- isSecret?: boolean;
}
export function AlmBindingDefinitionFormField<B extends AlmBindingDefinitionBase>(
export interface Props {
alm: AlmKeys;
- isUpdate: boolean;
+ bitbucketVariant?: AlmKeys.BitbucketServer | AlmKeys.BitbucketCloud;
canSubmit: boolean;
- onCancel: () => void;
- onSubmit: () => void;
- onFieldChange: (fieldId: keyof AlmBindingDefinition, value: string) => void;
+ errorListElementRef: React.RefObject<HTMLDivElement>;
formData: AlmBindingDefinition;
- submitting: boolean;
- bitbucketVariant?: AlmKeys.BitbucketServer | AlmKeys.BitbucketCloud;
+ isUpdate: boolean;
onBitbucketVariantChange: (
bitbucketVariant: AlmKeys.BitbucketServer | AlmKeys.BitbucketCloud,
) => void;
+ onCancel: () => void;
+ onFieldChange: (fieldId: keyof AlmBindingDefinition, value: string) => void;
+ onSubmit: () => void;
+ submitting: boolean;
validationError?: string;
- errorListElementRef: React.RefObject<HTMLDivElement>;
}
export default class AlmBindingDefinitionFormRenderer extends React.PureComponent<Readonly<Props>> {
interface State {
currentAlmTab: AlmTabs;
definitionKeyForDeletion?: string;
- definitions: AlmSettingsBindingDefinitions;
definitionStatus: Dict<AlmSettingsBindingStatus>;
+ definitions: AlmSettingsBindingDefinitions;
loadingAlmDefinitions: boolean;
loadingProjectCount: boolean;
projectCount?: number;
branchesEnabled: boolean;
currentAlmTab: AlmTabs;
definitionKeyForDeletion?: string;
- definitions: AlmSettingsBindingDefinitions;
definitionStatus: Dict<AlmSettingsBindingStatus>;
+ definitions: AlmSettingsBindingDefinitions;
loadingAlmDefinitions: boolean;
loadingProjectCount: boolean;
multipleAlmEnabled: boolean;
interface Props {
almTab: AlmTabs;
branchesEnabled: boolean;
- definitions: AlmBindingDefinition[];
definitionStatus: Dict<AlmSettingsBindingStatus>;
+ definitions: AlmBindingDefinition[];
loadingAlmDefinitions: boolean;
loadingProjectCount: boolean;
multipleAlmEnabled: boolean;
}
interface State {
- editedDefinition?: AlmBindingDefinition;
editDefinition?: boolean;
+ editedDefinition?: AlmBindingDefinition;
}
export default class AlmTab extends React.PureComponent<Props, State> {
import CreationTooltip from './CreationTooltip';
export interface AlmTabRendererProps {
+ afterSubmit: (config: AlmBindingDefinitionBase) => void;
almTab: AlmTabs;
branchesEnabled: boolean;
definitionStatus: Dict<AlmSettingsBindingStatus>;
+ definitions: AlmBindingDefinition[];
editDefinition?: boolean;
editedDefinition?: AlmBindingDefinition;
- definitions: AlmBindingDefinition[];
loadingAlmDefinitions: boolean;
loadingProjectCount: boolean;
multipleAlmEnabled: boolean;
onCreate: () => void;
onDelete: (definitionKey: string) => void;
onEdit: (definitionKey: string) => void;
- afterSubmit: (config: AlmBindingDefinitionBase) => void;
}
const AUTHENTICATION_AVAILABLE_PLATFORMS = [
fieldId: keyof (BitbucketServerBindingDefinition & BitbucketCloudBindingDefinition),
value: string,
) => void;
- variant?: AlmKeys.BitbucketServer | AlmKeys.BitbucketCloud;
onVariantChange: (variant: AlmKeys.BitbucketServer | AlmKeys.BitbucketCloud) => void;
+ variant?: AlmKeys.BitbucketServer | AlmKeys.BitbucketCloud;
}
export default function BitbucketForm(props: Readonly<BitbucketFormProps>) {
export interface DeleteModalProps {
id: string;
- projectCount?: number;
- onDelete: (id: string) => void;
onCancel: () => void;
+ onDelete: (id: string) => void;
+ projectCount?: number;
}
function showProjectCountWarning(projectCount?: number) {
import AuthenticationToggleFormField from './AuthenticationToggleField';
interface Props {
- settingValue?: string | boolean | string[];
+ className?: string;
definition: ExtendedSettingDefinition | DefinitionV2;
+ error?: string;
+ isNotSet: boolean;
mandatory?: boolean;
onFieldChange: (key: string, value: string | boolean | string[]) => void;
- isNotSet: boolean;
- error?: string;
- className?: string;
+ settingValue?: string | boolean | string[];
}
export default function AuthenticationFormField(props: Readonly<Props>) {
import { getPropertyName } from '../../utils';
interface Props {
+ definition: ExtendedSettingDefinition | DefinitionV2;
onFieldChange: (value: string[]) => void;
settingValue?: string[];
- definition: ExtendedSettingDefinition | DefinitionV2;
}
export default function AuthenticationMultiValueField(props: Props) {
import { isSecuredDefinition } from '../../utils';
interface SamlToggleFieldProps {
- onFieldChange: (key: string, value: string) => void;
- settingValue?: string;
definition: ExtendedSettingDefinition | DefinitionV2;
- optional?: boolean;
isNotSet: boolean;
+ onFieldChange: (key: string, value: string) => void;
+ optional?: boolean;
+ settingValue?: string;
}
export default function AuthenticationSecuredField(props: SamlToggleFieldProps) {
import { getPropertyName } from '../../utils';
interface SamlToggleFieldProps {
+ definition: ExtendedSettingDefinition | DefinitionV2;
onChange: (value: boolean) => void;
settingValue?: string | boolean;
- definition: ExtendedSettingDefinition | DefinitionV2;
}
export default function AuthenticationToggleField(props: SamlToggleFieldProps) {
import { translate } from '../../../../helpers/l10n';
interface Props {
- title: string;
- url: string | string[] | undefined;
canDisable: boolean;
- onEdit: () => void;
- onDelete: () => void;
- onToggle: () => void;
+ enabled: boolean;
extraActions?: ReactElement;
isDeleting: boolean;
- enabled: boolean;
+ onDelete: () => void;
+ onEdit: () => void;
+ onToggle: () => void;
+ title: string;
+ url: string | string[] | undefined;
}
export default function ConfigurationDetails(props: Readonly<Props>) {
interface Props {
allowUsersToSignUp?: boolean;
- provider: Provider.Github | Provider.Gitlab;
+ hasProvisioningTypeChange?: boolean;
isAllowListEmpty: boolean;
onClose: VoidFunction;
onConfirm: VoidFunction;
- hasProvisioningTypeChange?: boolean;
+ provider: Provider.Github | Provider.Gitlab;
provisioningStatus: ProvisioningType;
}
interface Props {
mapping: GitHubMapping[] | null;
- setMapping: React.Dispatch<React.SetStateAction<GitHubMapping[] | null>>;
onClose: () => void;
+ setMapping: React.Dispatch<React.SetStateAction<GitHubMapping[] | null>>;
}
interface PermissionCellProps {
+ list?: GitHubMapping[];
mapping: GitHubMapping;
setMapping: React.Dispatch<React.SetStateAction<GitHubMapping[] | null>>;
- list?: GitHubMapping[];
}
const DEFAULT_CUSTOM_ROLE_PERMISSIONS: GitHubMapping['permissions'] = {
import TabHeader from './TabHeader';
interface ChangesForm {
- provisioningType?: GitLabConfigurationUpdateBody['provisioningType'];
allowUsersToSignUp?: GitLabConfigurationUpdateBody['allowUsersToSignUp'];
- provisioningToken?: GitLabConfigurationUpdateBody['provisioningToken'];
allowedGroups?: GitLabConfigurationUpdateBody['allowedGroups'];
+ provisioningToken?: GitLabConfigurationUpdateBody['provisioningToken'];
+ provisioningType?: GitLabConfigurationUpdateBody['provisioningType'];
}
const getDefinitions = (
}
interface FormData {
- value: string | boolean | string[];
- required: boolean;
definition: DefinitionV2;
+ required: boolean;
+ value: string | boolean | string[];
}
const DEFAULT_URL = 'https://gitlab.com';
} from './hook/useGithubConfiguration';
interface GithubAuthenticationProps {
- definitions: ExtendedSettingDefinition[];
currentTab: AuthenticationTabs;
+ definitions: ExtendedSettingDefinition[];
}
const GITHUB_EXCLUDED_FIELD = ['sonar.auth.github.enabled', ...GITHUB_ADDITIONAL_FIELDS];
import { ProvisioningType } from '../../../../types/provisioning';
interface Props {
- isLoading?: boolean;
- provisioningType: ProvisioningType;
- onChangeProvisioningType: (val: ProvisioningType) => void;
- disabledConfigText: string;
- jitTitle: string;
- jitDescription: string | ReactElement;
- jitSettings?: ReactElement;
- autoTitle: string;
autoDescription: ReactElement;
- synchronizationDetails?: ReactElement;
- autoSettings?: ReactElement;
- hasFeatureEnabled: boolean;
- hasDifferentProvider: boolean;
autoFeatureDisabledText: string | ReactElement;
- onSave: (e: FormEvent) => void;
- onSyncNow?: () => void;
- onCancel: () => void;
- hasUnsavedChanges: boolean;
+ autoSettings?: ReactElement;
+ autoTitle: string;
canSave?: boolean;
canSync?: boolean;
+ disabledConfigText: string;
enabled: boolean;
+ hasDifferentProvider: boolean;
+ hasFeatureEnabled: boolean;
+ hasUnsavedChanges: boolean;
+ isLoading?: boolean;
+ jitDescription: string | ReactElement;
+ jitSettings?: ReactElement;
+ jitTitle: string;
+ onCancel: () => void;
+ onChangeProvisioningType: (val: ProvisioningType) => void;
+ onSave: (e: FormEvent) => void;
+ onSyncNow?: () => void;
+ provisioningType: ProvisioningType;
+ synchronizationDetails?: ReactElement;
}
export default function ProvisioningSection(props: Readonly<Props>) {
import { translate } from '../../../../helpers/l10n';
interface Props {
- title: string;
- showCreate: boolean;
- onCreate: () => void;
configurationValidity?: ReactElement;
+ onCreate: () => void;
+ showCreate: boolean;
+ title: string;
}
export default function TabHeader({
const intlPrefix = 'settings.authentication.configuration';
interface Props {
- loading: boolean;
- onTestConf: () => void;
- flagMessageVariant: Variant;
flagMessageContent: React.ReactNode;
flagMessageTitle: string;
+ flagMessageVariant: Variant;
+ loading: boolean;
+ onTestConf: () => void;
}
export default function GitLabConfigurationValidity(props: Readonly<Props>) {
export type SettingValue =
| {
+ definition: ExtendedSettingDefinition;
+ isNotSet: boolean;
key: string;
- multiValues: false;
mandatory: boolean;
- isNotSet: boolean;
- value?: string;
+ multiValues: false;
newValue?: string | boolean;
- definition: ExtendedSettingDefinition;
+ value?: string;
}
| {
+ definition: ExtendedSettingDefinition;
+ isNotSet: boolean;
key: string;
- multiValues: true;
mandatory: boolean;
- isNotSet: boolean;
- value?: string[];
+ multiValues: true;
newValue?: string[];
- definition: ExtendedSettingDefinition;
+ value?: string[];
};
export default function useConfiguration(
];
export interface SamlSettingValue {
+ definition: ExtendedSettingDefinition;
+ isNotSet: boolean;
key: string;
mandatory: boolean;
- isNotSet: boolean;
- value?: string;
newValue?: string | boolean;
- definition: ExtendedSettingDefinition;
+ value?: string;
}
export const isOrganizationListEmpty = (values: Record<string, SettingValue>) =>
export interface AlmSpecificFormProps extends WithAvailableFeaturesProps {
alm: AlmKeys;
- instances: AlmSettingsInstance[];
formData: Omit<ProjectAlmBindingResponse, 'alm'>;
+ instances: AlmSettingsInstance[];
onFieldChange: (id: keyof ProjectAlmBindingResponse, value: string | boolean) => void;
}
interface CommonFieldProps extends LabelProps {
help?: boolean;
- helpParams?: Dict<string | JSX.Element>;
helpExample?: JSX.Element;
+ helpParams?: Dict<string | JSX.Element>;
onFieldChange: (id: keyof ProjectAlmBindingResponse, value: string | boolean) => void;
propKey: keyof ProjectAlmBindingResponse;
}
function renderBooleanField(
props: Omit<CommonFieldProps, 'optional'> & {
- value: boolean;
inputExtra?: React.ReactNode;
+ value: boolean;
},
) {
const { id, value, onFieldChange, propKey, inputExtra } = props;
}
interface State {
+ checkingConfiguration: boolean;
+ configurationErrors?: ProjectAlmBindingConfigurationErrors;
formData: FormData;
instances: AlmSettingsInstance[];
isChanged: boolean;
isValid: boolean;
loading: boolean;
originalData?: FormData;
- updating: boolean;
successfullyUpdated: boolean;
- checkingConfiguration: boolean;
- configurationErrors?: ProjectAlmBindingConfigurationErrors;
+ updating: boolean;
}
const REQUIRED_FIELDS_BY_ALM: {
import AlmSpecificForm from './AlmSpecificForm';
export interface PRDecorationBindingRendererProps {
+ checkingConfiguration: boolean;
+ configurationErrors?: ProjectAlmBindingConfigurationErrors;
formData: Omit<ProjectAlmBindingResponse, 'alm'>;
instances: AlmSettingsInstance[];
isChanged: boolean;
isConfigured: boolean;
+ isSysAdmin: boolean;
isValid: boolean;
loading: boolean;
+ onCheckConfiguration: () => void;
onFieldChange: (id: keyof ProjectAlmBindingResponse, value: string | boolean) => void;
onReset: () => void;
onSubmit: () => void;
- updating: boolean;
successfullyUpdated: boolean;
- onCheckConfiguration: () => void;
- checkingConfiguration: boolean;
- configurationErrors?: ProjectAlmBindingConfigurationErrors;
- isSysAdmin: boolean;
+ updating: boolean;
}
export default function PRDecorationBindingRenderer(props: PRDecorationBindingRendererProps) {
},
])(
'should get, set, delete and validate binding for $alm',
- async ({ key, alm }: { key: string; alm: AlmKeys }) => {
+ async ({ key, alm }: { alm: AlmKeys; key: string }) => {
const { ui, user } = getPageObjects();
almSettings.setProjectBindingConfigurationErrors({
scope: ProjectAlmBindingConfigurationErrorScope.Global,
export const DEFAULT_CATEGORY = 'general';
export type DefaultSpecializedInputProps = DefaultInputProps & {
- className?: string;
autoComplete?: string;
+ className?: string;
isDefault: boolean;
name: string;
type?: string;
export interface DefaultInputProps {
autoFocus?: boolean;
+ hasValueChanged?: boolean;
isEditing?: boolean;
isInvalid?: boolean;
- size?: InputSizeKeys;
- hasValueChanged?: boolean;
onCancel?: () => void;
onChange: (value: any) => void;
onEditing?: () => void;
onSave?: () => void;
setting: Setting;
+ size?: InputSizeKeys;
value: any;
}
import PageActions from './PageActions';
export interface Props {
+ appState: AppState;
isCluster: boolean;
loading: boolean;
logLevel: string;
onLogLevelChange: () => void;
- appState: AppState;
serverId?: string;
version?: string;
}
interface Props {
health?: HealthTypes;
healthCauses?: string[];
+ name: string;
onClick: (toggledCard: string) => void;
open: boolean;
- name: string;
sysInfoData: SysInfoValueObject;
}
import HealthCauseItem from './HealthCauseItem';
interface Props {
- name?: string;
className?: string;
health: HealthTypes;
healthCauses?: string[];
+ name?: string;
}
export default function HealthItem({ className, name, health, healthCauses }: Readonly<Props>) {
import SysInfoItem from './SysInfoItem';
interface Props {
- name?: string;
items: SysInfoValueObject;
+ name?: string;
}
const COLUMNS = ['0', 'auto'];
interface Props {
identityProviders: IdentityProvider[];
- users: RestUserDetailed[];
manageProvider: Provider | undefined;
+ users: RestUserDetailed[];
}
export default function UsersList({ identityProviders, users, manageProvider }: Props) {
);
const [tokenExpirationOptions, setTokenExpirationOptions] =
- React.useState<{ value: TokenExpiration; label: string }[]>(EXPIRATION_OPTIONS);
+ React.useState<{ label: string; value: TokenExpiration }[]>(EXPIRATION_OPTIONS);
const { mutateAsync: generate, isPending: generating } = useGenerateTokenMutation();
import TokensForm from './TokensForm';
interface Props {
- user: RestUserDetailed;
onClose: () => void;
+ user: RestUserDetailed;
}
export default function TokensFormModal(props: Readonly<Props>) {
import UserForm from './UserForm';
interface Props {
- user: RestUserDetailed;
manageProvider: Provider | undefined;
+ user: RestUserDetailed;
}
export default function UserActions(props: Props) {
import UserScmAccountInput from './UserScmAccountInput';
export interface Props {
+ isInstanceManaged: boolean;
onClose: () => void;
user?: RestUserDetailed;
- isInstanceManaged: boolean;
}
const BAD_REQUEST = 400;
export interface UserListItemProps {
identityProvider?: IdentityProvider;
- user: RestUserDetailed;
manageProvider: Provider | undefined;
+ user: RestUserDetailed;
}
export default function UserListItem(props: Readonly<UserListItemProps>) {
export interface Props {
identityProvider?: IdentityProvider;
- user: RestUserDetailed;
manageProvider: Provider | undefined;
+ user: RestUserDetailed;
}
export default function UserListItemIdentity({ identityProvider, user, manageProvider }: Props) {
export interface Props {
idx: number;
- scmAccount: string;
onChange: (idx: number, scmAccount: string) => void;
onRemove: (idx: number) => void;
+ scmAccount: string;
}
export default function UserScmAccountInput(props: Props) {
import { cleanQuery, parseAsString, serializeString } from '../../helpers/query';
export interface Query {
- search: string;
managed?: boolean;
+ search: string;
}
export const parseQuery = memoize(
import { Dispatch, SetStateAction, createContext } from 'react';
const ApiFilterContext = createContext<{
- showInternal: boolean;
setShowInternal: Dispatch<SetStateAction<boolean>>;
+ showInternal: boolean;
}>({
showInternal: false,
setShowInternal: () => {},
import RestMethodPill from './RestMethodPill';
interface Props {
- data: ExcludeReferences<OpenAPIV3.OperationObject<InternalExtension>>;
apiUrl: string;
- name: string;
+ data: ExcludeReferences<OpenAPIV3.OperationObject<InternalExtension>>;
method: string;
+ name: string;
}
export default function ApiInformation({ name, data, method, apiUrl }: Readonly<Props>) {
import { Query } from '../utils';
interface Props {
- query: Query;
onSearch: (search: string) => void;
- onToggleInternal: () => void;
onToggleDeprecated: () => void;
+ onToggleInternal: () => void;
+ query: Query;
}
export default function Search(props: Props) {
}
}
-function WebApiAppWithParams(props: { router: Router; location: Location }) {
+function WebApiAppWithParams(props: { location: Location; router: Router }) {
const params = useParams();
return <WebApiApp {...props} params={{ splat: params['*'] }} />;
import { WebApi } from '../../types/types';
export interface Query {
- search: string;
deprecated: boolean;
internal: boolean;
+ search: string;
}
export function actionsFilter(query: Query, domain: WebApi.Domain, action: WebApi.Action) {
}
async function handleUpdate(data: {
- webhook: string;
name: string;
secret?: string;
url: string;
+ webhook: string;
}) {
await updateWebhook({ ...data });
setWebhooks((webhooks) =>
},
checkWebhookRow: (
index: number,
- expected: { name: string; url: string; secret: boolean; lastDeliveryDate?: string },
+ expected: { lastDeliveryDate?: string; name: string; secret: boolean; url: string },
) => {
const row = ui.getWebhookRow(index);
const [name, url, secret, lastDelivery] = within(row).getAllByRole('cell');
issues: Issue[] | undefined;
issuesByLine: { [line: number]: Issue[] };
loadDuplications: (line: SourceLine) => void;
- loadingSourcesAfter: boolean;
- loadingSourcesBefore: boolean;
loadSourcesAfter: () => void;
loadSourcesBefore: () => void;
+ loadingSourcesAfter: boolean;
+ loadingSourcesBefore: boolean;
metricKey?: string;
onIssueChange: (issue: Issue) => void;
onIssuePopupToggle: (issue: string, popupName: string, open?: boolean) => void;
- onIssuesClose: (line: SourceLine) => void;
onIssueSelect: (issueKey: string) => void;
- onIssuesOpen: (line: SourceLine) => void;
onIssueUnselect: () => void;
+ onIssuesClose: (line: SourceLine) => void;
+ onIssuesOpen: (line: SourceLine) => void;
onLocationSelect: ((index: number) => void) | undefined;
onSymbolClick: (symbols: string[]) => void;
openIssuesByLine: { [line: number]: boolean };
blocks: DuplicationBlock[];
branchLike: BranchLike | undefined;
duplicatedFiles?: Dict<DuplicatedFile>;
- inRemovedComponent: boolean;
duplicationHeader: string;
+ inRemovedComponent: boolean;
openComponent: WorkspaceContextShape['openComponent'];
sourceViewerFile: SourceViewerFile;
}
children?: React.ReactNode;
displayAllIssues?: boolean;
displayCoverage: boolean;
+ displayCoverageUnderline: boolean;
displayDuplications: boolean;
displayIssues: boolean;
displayLineNumberOptions?: boolean;
displayLocationMarkers?: boolean;
+ displayNewCodeUnderline: boolean;
displaySCM?: boolean;
duplications: number[];
duplicationsCount: number;
firstLineNumber: number;
+ hideLocationIndex?: boolean;
highlighted: boolean;
highlightedLocationMessage: { index: number; text: string | undefined } | undefined;
highlightedSymbols: string[] | undefined;
issues: Issue[];
line: SourceLine;
loadDuplications: (line: SourceLine) => void;
- onIssuesClose: (line: SourceLine) => void;
onIssueSelect: (issueKey: string) => void;
- onIssuesOpen: (line: SourceLine) => void;
onIssueUnselect: () => void;
+ onIssuesClose: (line: SourceLine) => void;
+ onIssuesOpen: (line: SourceLine) => void;
+ onLineMouseEnter: (line: number) => void;
+ onLineMouseLeave: (line: number) => void;
onLocationSelect: ((x: number) => void) | undefined;
onSymbolClick: (symbols: string[]) => void;
openIssues: boolean;
renderDuplicationPopup: (index: number, line: number) => React.ReactNode;
scrollToUncoveredLine?: boolean;
secondaryIssueLocations: LinearIssueLocation[];
- onLineMouseEnter: (line: number) => void;
- onLineMouseLeave: (line: number) => void;
- displayCoverageUnderline: boolean;
- displayNewCodeUnderline: boolean;
- hideLocationIndex?: boolean;
}
export default function Line(props: LineProps) {
branchLike: BranchLike | undefined;
displayAllIssues?: boolean;
displayWhyIsThisAnIssue: boolean;
- issuesForLine: TypeIssue[];
- issuePopup: { issue: string; name: string } | undefined;
issueLocationsByLine: { [line: number]: LinearIssueLocation[] };
+ issuePopup: { issue: string; name: string } | undefined;
+ issuesForLine: TypeIssue[];
line: SourceLine;
onIssueChange: (issue: TypeIssue) => void;
onIssueClick: (issueKey: string) => void;
analyses: ParsedAnalysis[];
graphEndDate?: Date;
graphStartDate?: Date;
- series: Serie[];
onClose: () => void;
+ series: Serie[];
}
type DataTableEntry = { date: Date } & { [x: string]: string | undefined };
);
renderProjectChange(project: {
+ branch?: string;
changeType: DefinitionChangeType;
key: string;
name: string;
- branch?: string;
newBranch?: string;
oldBranch?: string;
}) {
analyses: ParsedAnalysis[];
canShowDataAsTable?: boolean;
graph: string;
+ graphDescription: string;
graphEndDate?: Date;
graphStartDate?: Date;
- leakPeriodDate?: Date;
isCustom?: boolean;
+ leakPeriodDate?: Date;
measuresHistory: MeasureHistory[];
metricsType: string;
removeCustomMetric?: (metric: string) => void;
- showAreas: boolean;
- series: Serie[];
selectedDate?: Date;
- graphDescription: string;
+ series: Serie[];
+ showAreas: boolean;
updateGraphZoom?: (from?: Date, to?: Date) => void;
updateSelectedDate?: (selectedDate?: Date) => void;
updateTooltip: (selectedDate?: Date) => void;
import { getGraphTypes, isCustomGraph } from './utils';
interface Props {
- onAddCustomMetric?: (metric: string) => void;
className?: string;
- onRemoveCustomMetric?: (metric: string) => void;
graph: GraphType;
metrics: Metric[];
metricsTypeFilter?: string[];
- selectedMetrics?: string[];
+ onAddCustomMetric?: (metric: string) => void;
+ onRemoveCustomMetric?: (metric: string) => void;
onUpdateGraph: (graphType: string) => void;
+ selectedMetrics?: string[];
}
export default function GraphsHeader(props: Props) {
ariaLabel?: string;
canShowDataAsTable?: boolean;
graph: GraphType;
- graphs: Serie[][];
graphEndDate?: Date;
graphStartDate?: Date;
+ graphs: Serie[][];
leakPeriodDate?: Date;
loading: boolean;
measuresHistory: MeasureHistory[];
index: number;
metric: string;
name: string;
- showWarning?: boolean;
removeMetric?: (metric: string) => void;
+ showWarning?: boolean;
}
export function GraphsLegendItem({
import { ChartLegend } from './ChartLegend';
interface Props {
- name: string;
index: number;
+ name: string;
translatedName: string;
value: string;
}
leakPeriodDate?: Date;
loading: boolean;
metricsType: string;
+ onUpdateGraphZoom: (from?: Date, to?: Date) => void;
series: Serie[];
showAreas?: boolean;
- onUpdateGraphZoom: (from?: Date, to?: Date) => void;
}
const ZOOM_TIMELINE_PADDING_TOP = 0;
export function getActivityGraph(
namespace: string,
project: string,
-): { graph: GraphType; customGraphs: string[] } {
+): { customGraphs: string[]; graph: GraphType } {
const customGraphs = get(`${namespace}.custom`, project);
return {
import './LineChart.css';
export interface PropsWithoutTheme {
- graphDescription?: string;
basisCurve?: boolean;
- endDate?: Date;
disableZoom?: boolean;
+ endDate?: Date;
formatYTick?: (tick: number | string) => string;
+ graphDescription?: string;
+ height: number;
hideGrid?: boolean;
hideXAxis?: boolean;
- height: number;
- width: number;
leakPeriodDate?: Date;
// used to avoid same y ticks labels
maxYTicksCount?: number;
updateSelectedDate?: (selectedDate?: Date) => void;
updateTooltip?: (selectedDate?: Date, tooltipXPos?: number, tooltipIdx?: number) => void;
updateZoom?: (start?: Date, endDate?: Date) => void;
+ width: number;
zoomSpeed?: number;
}
maxXRange: number[];
mouseOver?: boolean;
selectedDate?: Date;
- selectedDateXPos?: number;
selectedDateIdx?: number;
- yScale: YScale;
+ selectedDateXPos?: number;
xScale: XScale;
+ yScale: YScale;
}
export class AdvancedTimelineClass extends React.PureComponent<Props, State> {
className?: string;
colorScale:
| ScaleOrdinal<string, string> // used for LEVEL type
- | ScaleLinear<string, string | number>; // used for RATING or PERCENT type
- naColors?: [CSSColor, CSSColor];
+ | ScaleLinear<string, string | number>;
height: number;
+ // used for RATING or PERCENT type
+ naColors?: [CSSColor, CSSColor];
padding?: [number, number, number, number];
showColorNA?: boolean;
width: number;
export type PropsWithDefaults = Props & typeof ZoomTimeLine.defaultProps;
interface State {
- overlayLeftPos?: number;
newZoomStart?: number;
+ overlayLeftPos?: number;
}
type XScale = ScaleTime<number, number>;
};
renderZoomHandle = (options: {
- xScale: XScale;
- xPos: number;
+ direction: string;
fixedPos: number;
- yDim: number[];
xDim: number[];
- direction: string;
+ xPos: number;
+ xScale: XScale;
+ yDim: number[];
}) => (
<Draggable
axis="x"
export interface DisableableSelectOptionProps {
className?: string;
- disabledReason?: string;
- option: { label?: string; value?: string | number | boolean; isDisabled?: boolean };
disableTooltipOverlay: () => React.ReactNode;
+ disabledReason?: string;
+ option: { isDisabled?: boolean; label?: string; value?: string | number | boolean };
}
export default function DisableableSelectOption(props: DisableableSelectOptionProps) {
import { DocLink } from '../../helpers/doc-links';
import { useDocUrl } from '../../helpers/docs';
-type Props = Omit<LinkProps, 'to'> & { to: DocLink; innerRef?: React.Ref<HTMLAnchorElement> };
+type Props = Omit<LinkProps, 'to'> & { innerRef?: React.Ref<HTMLAnchorElement>; to: DocLink };
export default function DocumentationLink({ to, innerRef, ...props }: Props) {
const toStatic = useDocUrl(to);
import * as React from 'react';
interface Props {
+ children: (position: { left: number; top: number }) => React.ReactElement<any>;
className?: string;
- children: (position: { top: number; left: number }) => React.ReactElement<any>;
}
export const SCREEN_POSITION_COMPUTE_DELAY = 250;
export interface VisibilitySelectorProps {
canTurnToPrivate?: boolean;
className?: string;
- onChange: (visibility: Visibility) => void;
- visibility?: Visibility;
disabled?: boolean;
loading?: boolean;
+ onChange: (visibility: Visibility) => void;
+ visibility?: Visibility;
}
export default function VisibilitySelector(props: Readonly<VisibilitySelectorProps>) {
interface Props {
appState: AppState;
- component: Component;
branch?: Branch;
+ component: Component;
currentUser: CurrentUser;
}
import { Component } from '../../types/types';
export interface ComponentReportActionsRendererProps {
- component: Component;
branch?: Branch;
- frequency: string;
- subscribed: boolean;
canSubscribe: boolean;
+ component: Component;
currentUserHasEmail: boolean;
+ frequency: string;
handleSubscription: () => void;
handleUnsubscription: () => void;
+ subscribed: boolean;
}
const getSubscriptionText = ({
component: string;
componentName?: string;
favorite: boolean;
- qualifier: string;
handleFavorite?: (component: string, isFavorite: boolean) => void;
+ qualifier: string;
}
interface State {
import * as React from 'react';
interface Props extends React.BaseHTMLAttributes<HTMLDivElement> {
- onFocusOut: () => void;
innerRef?: (instance: HTMLDivElement) => void;
+ onFocusOut: () => void;
}
export default class FocusOutHandler extends React.PureComponent<React.PropsWithChildren<Props>> {
onBlur: (event: React.FocusEvent<HTMLInputElement>) => void;
onChange: (event: React.ChangeEvent<HTMLInputElement>) => void;
placeholder?: string;
+ required?: boolean;
touched: boolean | undefined;
type?: string;
value: string;
- required?: boolean;
}
export default function InputValidationField({ ...props }: Readonly<Props>) {
import { translate, translateWithParameters } from '../../helpers/l10n';
export interface ListFooterProps {
- loadMoreAriaLabel?: string;
- count: number;
className?: string;
- loading?: boolean;
+ count: number;
loadMore?: () => void;
+ loadMoreAriaLabel?: string;
+ loading?: boolean;
needReload?: boolean;
pageSize?: number;
- reload?: () => void;
ready?: boolean;
+ reload?: () => void;
total?: number;
}
import { Provider } from '../../types/types';
interface ManagedFilterProps {
- manageProvider: Provider | undefined;
loading: boolean;
+ manageProvider: Provider | undefined;
managed: boolean | undefined;
setManaged: (managed: boolean | undefined) => void;
}
type Props = {
allowBulkSelection?: boolean;
+ autoFocusSearch?: boolean;
+ disabledElements?: string[];
elements: string[];
elementsTotalCount?: number;
- disabledElements?: string[];
+ labelAll?: string;
labelSelected?: string;
labelUnselected?: string;
- labelAll?: string;
needToReload?: boolean;
onSelect: (element: string) => Promise<void>;
onUnselect: (element: string) => Promise<void>;
renderElement: (element: string) => React.ReactNode;
selectedElements: string[];
withPaging?: boolean;
- autoFocusSearch?: boolean;
} & (
| {
- onSearch: (searchParams: SelectListSearchParams) => Promise<void>;
loading?: never;
+ onSearch: (searchParams: SelectListSearchParams) => Promise<void>;
}
| {
loading: boolean;
interface Props {
allowBulkSelection?: boolean;
- elements: string[];
disabledElements: string[];
+ elements: string[];
filter: SelectListFilter;
onSelect: (element: string) => Promise<void>;
onUnselect: (element: string) => Promise<void>;
export type Placement = 'bottom' | 'right' | 'left' | 'top';
interface TooltipProps {
- classNameSpace?: string;
children: React.ReactElement;
- mouseEnterDelay?: number;
- mouseLeaveDelay?: number;
- onShow?: () => void;
- onHide?: () => void;
+ classNameInner?: string;
+ classNameSpace?: string;
content: React.ReactNode;
- side?: Placement;
- isOpen?: boolean;
// If tooltip overlay has interactive content (links for instance) we may set this to true to stop
// default behavior of tabbing (other changes should be done outside of this component to make it work)
// See example DocHelpTooltip
isInteractive?: boolean;
- classNameInner?: string;
+ isOpen?: boolean;
+ mouseEnterDelay?: number;
+ mouseLeaveDelay?: number;
+ onHide?: () => void;
+ onShow?: () => void;
+ side?: Placement;
}
interface Measurements {
}
interface Props {
- instances: AlmInstanceBase[];
- initialValue?: string;
- onChange: (instance: AlmInstanceBase) => void;
className: string;
+ initialValue?: string;
inputId: string;
+ instances: AlmInstanceBase[];
+ onChange: (instance: AlmInstanceBase) => void;
}
export default function AlmSettingsInstanceSelector(props: Props) {
import { Dict } from '../../types/types';
interface Props extends IconProps {
- severity: string | null | undefined;
disabled?: boolean;
+ severity: string | null | undefined;
}
const severityIcons: Dict<(props: IconProps) => React.ReactElement> = {
issue: TypeIssue;
onChange: (issue: TypeIssue) => void;
onCheck?: (issue: string) => void;
- onSelect: (issueKey: string) => void;
onPopupToggle: (issue: string, popupName: string, open?: boolean) => void;
+ onSelect: (issueKey: string) => void;
openPopup?: string;
selected: boolean;
}
import SonarLintBadge from './SonarLintBadge';
interface Props {
- issue: Issue;
+ canSetTags?: boolean;
currentPopup?: string;
+ issue: Issue;
onAssign: (login: string) => void;
onChange: (issue: Issue) => void;
- togglePopup: (popup: string, show?: boolean) => void;
showSonarLintBadge?: boolean;
showTags?: boolean;
- canSetTags?: boolean;
+ togglePopup: (popup: string, show?: boolean) => void;
}
export default function IssueActionsBar(props: Readonly<Props>) {
import Avatar from '../../ui/Avatar';
interface Props {
- issue: Issue;
- isOpen: boolean;
canAssign: boolean;
+ isOpen: boolean;
+ issue: Issue;
onAssign: (login: string) => void;
togglePopup: (popup: string, show?: boolean) => void;
}
import { Issue } from '../../../types/types';
export interface IssueMessageProps {
- issue: Issue;
branchLike?: BranchLike;
displayWhyIsThisAnIssue?: boolean;
+ issue: Issue;
}
export default function IssueMessage(props: IssueMessageProps) {
issue: Pick<Issue, 'key' | 'tags'>;
onChange: (issue: Issue) => void;
open?: boolean;
- togglePopup: (popup: string, show?: boolean) => void;
tagsToDisplay?: number;
+ togglePopup: (popup: string, show?: boolean) => void;
}
export class IssueTags extends React.PureComponent<Props> {
import { IssueTransition } from '../../../types/issues';
type Props = {
- transition: IssueTransition;
- selected: boolean;
onSelectTransition: (transition: IssueTransition) => void;
+ selected: boolean;
+ transition: IssueTransition;
};
export function IssueTransitionItem({ transition, selected, onSelectTransition }: Readonly<Props>) {
import { IssueTransitionItem } from './IssueTransitionItem';
export type Props = {
+ guideStepIndex: number;
issue: Pick<Issue, 'transitions' | 'actions'>;
+ loading?: boolean;
onClose: () => void;
onSetTransition: (transition: IssueTransition, comment?: string) => void;
- guideStepIndex: number;
- loading?: boolean;
};
export function IssueTransitionOverlay(props: Readonly<Props>) {
import './SingleFileLocationNavigator.css';
interface Props {
+ concealedMarker?: boolean;
index: number;
message: string | undefined;
messageFormattings?: MessageFormatting[];
onClick: (index: number) => void;
selected: boolean;
- concealedMarker?: boolean;
}
export default class SingleFileLocationNavigator extends React.PureComponent<Props> {
interface Props {
className?: string;
- size?: number;
description?: React.ReactNode;
+ size?: number;
}
export function SonarLintLogo({ className, description, size }: Readonly<Props>) {
export interface Props {
className?: string;
- days: string;
currentDaysValue?: string;
- previousNonCompliantValue?: string;
- projectKey?: string;
- updatedAt?: number;
+ days: string;
disabled?: boolean;
isChanged: boolean;
isValid: boolean;
onChangeDays: (value: string) => void;
onSelect: (selection: NewCodeDefinitionType) => void;
+ previousNonCompliantValue?: string;
+ projectKey?: string;
selected: boolean;
settingLevel: NewCodeDefinitionLevels;
+ updatedAt?: number;
}
export default function NewCodeDefinitionDaysOption(props: Props) {
import { NewCodeDefinitionLevels } from './utils';
interface Props {
- onNcdChanged: (ncd: NewCodeDefinitiondWithCompliance) => void;
isMultipleProjects?: boolean;
+ onNcdChanged: (ncd: NewCodeDefinitiondWithCompliance) => void;
}
export default function NewCodeDefinitionSelector(props: Props) {
interface Props {
filter: FilterOption;
- query: string;
- onFilter: (filter: string) => void;
- onQuery: (query: string) => void;
groups: PermissionGroup[];
groupsPaging?: Paging;
- onRevokePermissionFromGroup: (group: string, permission: string) => Promise<void>;
+ loading?: boolean;
+ onFilter: (filter: string) => void;
onGrantPermissionToGroup: (group: string, permission: string) => Promise<void>;
- users: PermissionUser[];
- usersPaging?: Paging;
- onRevokePermissionFromUser: (user: string, permission: string) => Promise<void>;
onGrantPermissionToUser: (user: string, permission: string) => Promise<void>;
- permissions: Array<PermissionDefinition | PermissionDefinitionGroup>;
onLoadMore: () => void;
- selectedPermission?: string;
+ onQuery: (query: string) => void;
+ onRevokePermissionFromGroup: (group: string, permission: string) => Promise<void>;
+ onRevokePermissionFromUser: (user: string, permission: string) => Promise<void>;
onSelectPermission?: (permissions?: string) => void;
- loading?: boolean;
+ permissions: Array<PermissionDefinition | PermissionDefinitionGroup>;
+ query: string;
+ selectedPermission?: string;
+ users: PermissionUser[];
+ usersPaging?: Paging;
}
export default class AllHoldersList extends React.PureComponent<Props> {
import usePermissionChange from './usePermissionChange';
interface Props {
+ disabled?: boolean;
group: PermissionGroup;
isComponentPrivate?: boolean;
onToggle: (group: PermissionGroup, permission: string) => Promise<void>;
permissions: PermissionDefinitions;
- selectedPermission?: string;
- disabled?: boolean;
removeOnly?: boolean;
+ selectedPermission?: string;
}
export const ANYONE = 'Anyone';
export interface PermissionCellProps {
disabled?: boolean;
- removeOnly?: boolean;
loading: string[];
onCheck: (checked: boolean, permission?: string) => void;
permission: PermissionDefinition | PermissionDefinitionGroup;
permissionItem: PermissionGroup | PermissionUser;
- selectedPermission?: string;
prefixID: string;
+ removeOnly?: boolean;
+ selectedPermission?: string;
}
export default function PermissionCell(props: PermissionCellProps) {
import usePermissionChange from './usePermissionChange';
interface Props {
+ disabled?: boolean;
onToggle: (user: PermissionUser, permission: string) => Promise<void>;
permissions: PermissionDefinitions;
+ removeOnly?: boolean;
selectedPermission?: string;
user: PermissionUser;
- disabled?: boolean;
- removeOnly?: boolean;
}
export default function UserHolder(props: Props) {
interface Props<T extends PermissionGroup | PermissionUser> {
holder: T;
- removeOnly?: boolean;
- permissions: PermissionDefinitions;
onToggle: (holder: T, permission: string) => Promise<void>;
+ permissions: PermissionDefinitions;
+ removeOnly?: boolean;
}
export default function usePermissionChange<T extends PermissionGroup | PermissionUser>(
import RuleDescription from './RuleDescription';
interface IssueTabViewerProps extends CurrentUserContextInterface {
- ruleDetails: RuleDetails;
- extendedDescription?: string;
- ruleDescriptionContextKey?: string;
- codeTabContent?: React.ReactNode;
activityTabContent?: React.ReactNode;
+ codeTabContent?: React.ReactNode;
+ extendedDescription?: string;
+ issue: Issue;
location: Location;
+ onIssueChange: (issue: Issue) => void;
+ ruleDescriptionContextKey?: string;
+ ruleDetails: RuleDetails;
selectedFlowIndex?: number;
selectedLocationIndex?: number;
- issue: Issue;
- onIssueChange: (issue: Issue) => void;
}
interface State {
- tabs: Tab[];
- selectedTab?: Tab;
displayEducationalPrinciplesNotification?: boolean;
educationalPrinciplesNotificationHasBeenDismissed?: boolean;
+ selectedTab?: Tab;
+ tabs: Tab[];
}
export interface Tab {
- value: TabKeys;
- key: TabKeys;
- label: string;
content: React.ReactNode;
counter?: number;
+ key: TabKeys;
+ label: string;
+ value: TabKeys;
}
export enum TabKeys {
}
interface RuleDescriptionContextDisplay {
- displayName: string;
content: string;
+ displayName: string;
key: string;
}
import RuleDescription from './RuleDescription';
interface RuleTabViewerProps extends CurrentUserContextInterface {
- ruleDetails: RuleDetails;
location: Location;
+ ruleDetails: RuleDetails;
}
interface State {
- tabs: Tab[];
- selectedTab?: Tab;
displayEducationalPrinciplesNotification?: boolean;
educationalPrinciplesNotificationHasBeenDismissed?: boolean;
+ selectedTab?: Tab;
+ tabs: Tab[];
}
export interface Tab {
- value: TabKeys;
- label: string;
content: React.ReactNode;
counter?: number;
+ label: string;
+ value: TabKeys;
}
export enum TabKeys {
import DocumentationLink from '../common/DocumentationLink';
interface AnalysisMissingInfoMessageProps {
+ className?: string;
hide?: boolean;
qualifier: string;
- className?: string;
}
export default function AnalysisMissingInfoMessage({
export interface Props {
className?: string;
- type?: 'issue' | 'rule';
- cleanCodeAttributeCategory: CleanCodeAttributeCategory;
cleanCodeAttribute?: CleanCodeAttribute;
+ cleanCodeAttributeCategory: CleanCodeAttributeCategory;
+ type?: 'issue' | 'rule';
}
export function CleanCodeAttributePill(props: Readonly<Props>) {
children?: React.ReactNode;
className?: string;
component: string;
- metric: string;
inNewCodePeriod?: boolean;
+ metric: string;
}
export default class DrilldownLink extends React.PureComponent<Props> {
export interface Props {
className?: string;
+ quality: string;
severity: SoftwareImpactSeverity;
type?: 'issue' | 'rule';
- quality: string;
}
export default function SoftwareImpactPill(props: Props) {
import SoftwareImpactPill from './SoftwareImpactPill';
interface SoftwareImpactPillListProps extends React.HTMLAttributes<HTMLUListElement> {
- softwareImpacts: SoftwareImpact[];
className?: string;
+ softwareImpacts: SoftwareImpact[];
type?: Parameters<typeof SoftwareImpactPill>[0]['type'];
}
interface Props {
allowUpdate?: boolean;
className?: string;
- tags: string[];
overlay?: React.ReactNode;
+ tags: string[];
tagsClassName?: string;
tagsToDisplay?: number;
}
export interface TutorialSelectionProps {
component: Component;
currentUser: LoggedInUser;
- willRefreshAutomatically?: boolean;
location: Location;
+ willRefreshAutomatically?: boolean;
}
export function TutorialSelection(props: Readonly<TutorialSelectionProps>) {
import AnalysisCommand from './commands/AnalysisCommand';
export interface BranchesAnalysisStepProps {
- languages: Languages;
component: Component;
+ languages: Languages;
onDone: (done: boolean) => void;
}
import Other from './Other';
export interface AnalysisCommandProps {
- projectKey: string;
- projectName: string;
buildTool?: BuildTools;
onStepValidationChange: (isValid: boolean) => void;
+ projectKey: string;
+ projectName: string;
}
export default function AnalysisCommand(props: AnalysisCommandProps) {
import PublishSteps from './PublishSteps';
export interface ClangGCCProps {
- projectKey: string;
onStepValidationChange: (isValid: boolean) => void;
+ projectKey: string;
}
type OsConstant = {
export interface AnalysisCommandProps extends WithAvailableFeaturesProps {
buildTool: BuildTools;
- mainBranchName: string;
component: Component;
+ mainBranchName: string;
}
const YamlTemplate: Dictionary<
interface State {
loading: boolean;
token?: string;
- tokenName: string;
tokenExpiration: TokenExpiration;
- tokenExpirationOptions: { value: TokenExpiration; label: string }[];
+ tokenExpirationOptions: { label: string; value: TokenExpiration }[];
+ tokenName: string;
}
interface Props {
import { OSs, TutorialModes } from '../types';
export interface GithubCFamilyExampleRepositoriesProps {
+ ci?: TutorialModes;
className?: string;
os?: OSs;
- ci?: TutorialModes;
}
const OS_SEARCH_MAP = {
import { GradleBuildDSL } from '../types';
interface Props {
- className?: string;
children: (build: GradleBuildDSL) => React.ReactNode;
+ className?: string;
}
export default function GradleBuildSelection({ children, className }: Props) {
onCheck: (checked: string) => void;
optionLabelKey: string;
options: string[];
- titleLabelKey?: string;
setDone?: (doneStatus: boolean) => void;
+ titleLabelKey?: string;
}
export default function RenderOptions({
export interface SentenceWithHighlightsProps {
highlightKeys: string[];
- translationKey: string;
highlightPrefixKeys?: string;
+ translationKey: string;
}
export default function SentenceWithHighlights({
export interface AnalysisCommandProps extends WithAvailableFeaturesProps {
buildTool: BuildTools;
- mainBranchName: string;
component: Component;
+ mainBranchName: string;
monorepo?: boolean;
}
baseUrl: string;
component: Component;
currentUser: LoggedInUser;
- monorepo?: boolean;
mainBranchName: string;
+ monorepo?: boolean;
willRefreshAutomatically?: boolean;
}
export interface CFamilyProps {
branchesEnabled?: boolean;
+ component: Component;
mainBranchName: string;
monorepo?: boolean;
- component: Component;
}
const STEPS = {
export interface DotNetProps {
branchesEnabled?: boolean;
+ component: Component;
mainBranchName: string;
monorepo?: boolean;
- component: Component;
}
function dotnetYamlSteps(projectKey: string) {
export interface GradleProps {
branchesEnabled?: boolean;
+ component: Component;
mainBranchName: string;
monorepo?: boolean;
- component: Component;
}
const GRADLE_YAML_STEPS = `
export interface JavaMavenProps {
branchesEnabled?: boolean;
+ component: Component;
mainBranchName: string;
monorepo?: boolean;
- component: Component;
}
function mavenYamlSteps(projectKey: string, projectName: string) {
export interface OthersProps {
branchesEnabled?: boolean;
+ component: Component;
mainBranchName: string;
monorepo?: boolean;
- component: Component;
}
function otherYamlSteps(branchesEnabled: boolean) {
}
export interface LanguageProps {
- onDone: (done: boolean) => void;
- component: Component;
baseUrl: string;
+ component: Component;
+ onDone: (done: boolean) => void;
}
export function JenkinsfileStep(props: JenkinsfileStepProps) {
import { DotNetCoreFrameworkProps, OSDotNet } from './DotNet';
import DotNetPrereqsScanner from './DotNetPrereqsScanner';
-const OSS_DEP: { [key in OSDotNet]: { shell: string; pathSeparator: string } } = {
+const OSS_DEP: { [key in OSDotNet]: { pathSeparator: string; shell: string } } = {
[OSs.Linux]: { shell: 'sh', pathSeparator: '/' },
[OSs.Windows]: { shell: 'bat', pathSeparator: '\\\\' },
};
import { BuildTools, ManualTutorialConfig, OSs, TutorialModes } from '../types';
interface Props {
- hasCLanguageFeature: boolean;
config?: ManualTutorialConfig;
+ hasCLanguageFeature: boolean;
onDone: (config: ManualTutorialConfig) => void;
}
}
interface Props {
+ baseUrl: string;
component: Component;
currentUser: LoggedInUser;
- baseUrl: string;
isLocal?: boolean;
}
import AnalysisCommand from './commands/AnalysisCommand';
interface Props {
+ baseUrl: string;
component: Component;
+ isLocal: boolean;
onFinish?: (projectKey?: string) => void;
open: boolean;
- baseUrl: string;
stepNumber: number;
- isLocal: boolean;
token?: string;
}
interface Props {
currentUser: Pick<LoggedInUser, 'login'>;
- projectKey: string;
finished: boolean;
initialTokenName?: string;
- stepNumber: number;
- open: boolean;
onContinue: (token: string) => void;
onOpen: VoidFunction;
+ open: boolean;
+ projectKey: string;
+ stepNumber: number;
}
interface State {
existingToken: string;
loading: boolean;
selection: string;
- tokenName?: string;
token?: string;
- tokens?: UserToken[];
tokenExpiration: TokenExpiration;
- tokenExpirationOptions: { value: TokenExpiration; label: string }[];
+ tokenExpirationOptions: { label: string; value: TokenExpiration }[];
+ tokenName?: string;
+ tokens?: UserToken[];
}
const TOKEN_FORMAT_REGEX = /^[_a-z0-9]+$/;
import Other from './Other';
export interface AnalysisCommandProps {
- component: Component;
baseUrl: string;
+ component: Component;
isLocal: boolean;
languageConfig: ManualTutorialConfig;
token?: string;
import ExecScanner from './ExecScanner';
export interface ClangGCCCustomProps {
- component: Component;
baseUrl: string;
+ component: Component;
isLocal: boolean;
os: OSs;
token: string;
import DotNetFramework from './DotNetFramework';
export interface DotNetProps {
- component: Component;
baseUrl: string;
+ component: Component;
token: string;
}
import { OSs } from '../../types';
export interface DownloadBuildWrapperProps {
+ baseUrl: string;
isLocal: boolean;
os: OSs;
- baseUrl: string;
}
const FILENAMES: { [x in OSs]: string } = {
import DoneNextSteps from '../DoneNextSteps';
export interface ExecScannerProps {
- component: Component;
baseUrl: string;
+ cfamily?: boolean;
+ component: Component;
isLocal: boolean;
os: OSs;
token: string;
- cfamily?: boolean;
}
export default function ExecScanner(props: ExecScannerProps) {
import DoneNextSteps from '../DoneNextSteps';
export interface JavaGradleProps {
- component: Component;
baseUrl: string;
+ component: Component;
token: string;
}
import DoneNextSteps from '../DoneNextSteps';
export interface JavaMavenProps {
- component: Component;
baseUrl: string;
+ component: Component;
token: string;
}
import ExecScanner from './ExecScanner';
export interface OtherProps {
+ baseUrl: string;
component: Component;
isLocal: boolean;
- baseUrl: string;
os: OSs;
token: string;
}
import { SYSTEM_VERSION_REGEXP, UpdateUseCase } from './utils';
interface Props {
+ latestLTA?: string;
onClose: () => void;
systemUpgrades: SystemUpgrade[][];
- latestLTA?: string;
updateUseCase: UpdateUseCase;
}
componentKey,
branchLike,
}: {
- componentKey: string;
branchLike?: BranchLike;
+ componentKey: string;
}) {
const { openComponent } = React.useContext(WorkspaceContext);
type QueryHook<TData, TArgs extends any[]> = (...args: TArgs) => UseQueryResult<TData>;
interface Props<TData, TArgs extends any[]> {
- query: QueryHook<TData, TArgs>;
args?: TArgs;
children: (value: UseQueryResult<TData>) => ReactElement | null;
+ query: QueryHook<TData, TArgs>;
}
export default function UseQuery<TData, TArgs extends any[]>(props: Props<TData, TArgs>) {
const NUMBER_OF_EXAMPLES = 2;
-type DiffBlock = { noncompliant: Element; compliant: Element };
+type DiffBlock = { compliant: Element; noncompliant: Element };
export default function applyCodeDifferences(element: Element | null) {
if (element === null) {
export function getEditionUrl(
edition: Edition,
- data: { serverId?: string; ncloc?: number; sourceEdition?: EditionKey },
+ data: { ncloc?: number; serverId?: string; sourceEdition?: EditionKey },
) {
let url = edition.homeUrl;
const query = new URLSearchParams(omitNil(data)).toString();
function splitFlows(
issue: RawIssue,
components: Component[] = [],
-): { secondaryLocations: FlowLocation[]; flows: FlowLocation[][]; flowsWithType: Flow[] } {
+): { flows: FlowLocation[][]; flowsWithType: Flow[]; secondaryLocations: FlowLocation[] } {
if (issue.flows?.some((flow) => flow.type !== undefined)) {
const flowsWithType = issue.flows.filter((flow) => flow.type !== undefined) as Flow[];
flowsWithType.sort((f1, f2) => FLOW_ORDER_MAP[f1.type] - FLOW_ORDER_MAP[f2.type]);
private readonly options: { method?: string } = {},
) {}
- getSubmitData(customHeaders: any = {}): { url: string; options: RequestInit } {
+ getSubmitData(customHeaders: any = {}): { options: RequestInit; url: string } {
let { url } = this;
const options: RequestInit = { ...DEFAULT_OPTIONS, ...this.options };
}
export function mockDocumentationMarkdown(
- overrides: Partial<{ content: string; title: string; key: string }> = {},
+ overrides: Partial<{ content: string; key: string; title: string }> = {},
): string {
const content =
overrides.content ||
import { mockAppState, mockCurrentUser } from './testMocks';
export interface RenderContext {
- metrics?: Dict<Metric>;
appState?: AppState;
- languages?: Languages;
currentUser?: CurrentUser;
- navigateTo?: string;
featureList?: Feature[];
+ languages?: Languages;
+ metrics?: Dict<Metric>;
+ navigateTo?: string;
}
export function renderAppWithAdminContext(
indexPath: string,
routes: () => JSX.Element,
context: RenderContext = {},
- overrides: { systemStatus?: SysStatus; adminPages?: Extension[] } = {},
+ overrides: { adminPages?: Extension[]; systemStatus?: SysStatus } = {},
): RenderResult {
function MockAdminContainer() {
return (
* Generate URL for a component's drilldown page
*/
export function getComponentDrilldownUrl(options: {
+ asc?: boolean;
+ branchLike?: BranchLike;
componentKey: string;
+ listView?: boolean;
metric: string;
- branchLike?: BranchLike;
selectionKey?: string;
treemapView?: boolean;
- listView?: boolean;
- asc?: boolean;
}): To {
const { componentKey, metric, branchLike, selectionKey, treemapView, listView, asc } = options;
const query: Query = { id: componentKey, metric, ...getBranchLikeQuery(branchLike) };
initialValue,
valueToSet,
}: Readonly<{
- lsKey: string;
condition: (value: boolean | string) => boolean;
- valueToSet: boolean | string;
initialValue?: boolean | string;
+ lsKey: string;
+ valueToSet: boolean | string;
}>) {
const [value, setValue] = useLocalStorage(lsKey, initialValue);
const queryClient = useQueryClient();
const invalidateKey = useMutateBranchQueryKey();
- type ExcludeFromPurgeArg = { component: Component; key: string; exclude: boolean };
+ type ExcludeFromPurgeArg = { component: Component; exclude: boolean; key: string };
return useMutation({
mutationFn: async ({ component, key, exclude }: ExcludeFromPurgeArg) => {
}
export function useRenameMainBranchMutation() {
- type RenameMainBranchArg = { name: string; component: Component };
+ type RenameMainBranchArg = { component: Component; name: string };
const queryClient = useQueryClient();
const invalidateKey = useMutateBranchQueryKey();
}
export interface WithBranchLikesProps {
- branchLikes?: BranchLike[];
branchLike?: BranchLike;
+ branchLikes?: BranchLike[];
isFetchingBranch?: boolean;
}
const TASK_RETRY = 10_000;
type QueryKeyData = {
- metricKeys: string[];
branchParameters: BranchParameters;
+ metricKeys: string[];
};
function getComponentQueryKey(key: string, type: 'tasks'): string[];
return ['component', key, type, JSON.stringify(data)];
}
-function extractQueryKeyData(queryKey: string[]): { key: string; data?: QueryKeyData } {
+function extractQueryKeyData(queryKey: string[]): { data?: QueryKeyData; key: string } {
const [, key, , data] = queryKey;
return { key, data: JSON.parse(data ?? 'null') };
}
repository: string;
} & (
| { alm: AlmKeys.Azure | AlmKeys.BitbucketServer; slug: string; summaryCommentEnabled?: never }
- | { alm: AlmKeys.GitHub; summaryCommentEnabled: boolean; slug?: never }
+ | { alm: AlmKeys.GitHub; slug?: never; summaryCommentEnabled: boolean }
| {
alm: Exclude<AlmKeys, AlmKeys.Azure | AlmKeys.GitHub | AlmKeys.BitbucketServer>;
slug?: never;
export function useGroupMembersQuery(params: {
filter?: SelectListFilter;
- q?: string;
groupId: string;
pageIndex?: number;
+ q?: string;
}) {
return useInfiniteQuery({
queryKey: [DOMAIN, GROUP_SUB_DOMAIN, 'list', params],
const queryClient = useQueryClient();
return useMutation({
- mutationFn: async ({ userId, groupId }: { userId: string; groupId: string }) => {
+ mutationFn: async ({ userId, groupId }: { groupId: string; userId: string }) => {
const memberships = await getGroupMemberships({ userId, groupId, pageSize: 1 });
if (!memberships.page.total) {
throw new Error(
id,
data,
}: {
- id: Parameters<typeof updateGroup>[0];
data: Parameters<typeof updateGroup>[1];
+ id: Parameters<typeof updateGroup>[0];
}) => updateGroup(id, data),
onSuccess() {
queryClient.invalidateQueries({ queryKey: ['group', 'list'] });
id,
data,
}: {
- id: Parameters<typeof updateGitLabConfiguration>[0];
data: Parameters<typeof updateGitLabConfiguration>[1];
+ id: Parameters<typeof updateGitLabConfiguration>[0];
}) => updateGitLabConfiguration(id, data),
onSuccess(data) {
client.invalidateQueries({ queryKey: ['identity_provider', 'users_and_groups_provider'] });
export type MutationArg<AlmImport extends ImportProjectParam = ImportProjectParam> =
AlmImport extends {
- creationMode: infer A;
almSetting: string;
+ creationMode: infer A;
monorepo: false;
projects: (infer R)[];
}
- ? { creationMode: A; almSetting: string; monorepo: false } & R
+ ? { almSetting: string; creationMode: A; monorepo: false } & R
:
| {
creationMode: CreateProjectModes.Manual;
- project: string;
- name: string;
mainBranch: string;
monorepo: false;
+ name: string;
+ project: string;
}
| {
creationMode: CreateProjectModes;
return useMutation({
mutationFn: (newCodeDefinition: {
- project?: string;
branch?: string;
+ project?: string;
type?: NewCodeDefinitionType;
value?: string;
}) => {
weakConditions,
missingConditions,
}: {
- weakConditions: Condition[];
missingConditions: Condition[];
+ weakConditions: Condition[];
}) => {
const promiseArr = weakConditions
.map((condition) => {
}
export function useRuleDetailsQuery<T = Awaited<ReturnType<typeof getRuleDetails>>>(
- data: { key: string; actives?: boolean },
+ data: { actives?: boolean; key: string },
options?: Omit<
UseQueryOptions<Awaited<ReturnType<typeof getRuleDetails>>, Error, T>,
'queryKey' | 'queryFn'
export function useResetSettingsMutation() {
const queryClient = useQueryClient();
return useMutation({
- mutationFn: ({ keys, component }: { keys: string[]; component?: string }) =>
+ mutationFn: ({ keys, component }: { component?: string; keys: string[] }) =>
resetSettingValue({ keys: keys.join(','), component }),
onSuccess: (_, { keys }) => {
keys.forEach((key) => {
return useMutation({
mutationFn: (
values: {
- newValue?: SettingValue;
definition: ExtendedSettingDefinition;
+ newValue?: SettingValue;
}[],
) => {
return Promise.all(
definition,
component,
}: {
- newValue: SettingValue;
- definition: ExtendedSettingDefinition;
component?: string;
+ definition: ExtendedSettingDefinition;
+ newValue: SettingValue;
}) => {
if (isDefaultValue(newValue, definition)) {
return resetSettingValue({ keys: definition.key, component });
id,
data,
}: {
- id: Parameters<typeof updateUser>[0];
data: Parameters<typeof updateUser>[1];
+ id: Parameters<typeof updateUser>[0];
}) => updateUser(id, data),
onSuccess() {
queryClient.invalidateQueries({ queryKey: ['user', 'list'] });
export interface A11yContextShape {
addA11ySkipLink: (link: A11ySkipLink) => void;
- removeA11ySkipLink: (link: A11ySkipLink) => void;
links: A11ySkipLink[];
+ removeA11ySkipLink: (link: A11ySkipLink) => void;
}
export const A11yContext = createContext<A11yContextShape>({
content?: React.ReactNode;
linkTextLabel?: string;
links?: Array<
- { label?: string; inPlace?: boolean } & (
+ { inPlace?: boolean; label?: string } & (
| { doc?: true; href: DocLink }
| { doc: false; href: string }
)
import RatingTooltipContent from '../../../components/measure/RatingTooltipContent';
interface Props {
- className?: string;
badgeSize?: 'xs' | 'sm' | 'md';
+ className?: string;
decimals?: number;
fontClassName?: `sw-body-${string}` | `sw-heading-lg`;
metricKey: string;
export interface Router {
navigate: NavigateFunction;
- replace: (location: string | Partial<Location>) => void;
push: (location: string | Partial<Location>) => void;
+ replace: (location: string | Partial<Location>) => void;
searchParams: URLSearchParams;
setSearchParams: (
nextInit: URLSearchParamsInit,
import { Dict } from './types';
export interface AzureProject {
- name: string;
description: string;
+ name: string;
}
export interface AzureRepository {
id: number;
name: string;
projectKey: string;
- sqProjectKey?: string;
slug: string;
+ sqProjectKey?: string;
}
export interface BitbucketCloudRepository {
- uuid: number;
name: string;
projectKey: string;
- sqProjectKey?: string;
slug: string;
+ sqProjectKey?: string;
+ uuid: number;
workspace: string;
}
id: string;
key: string;
name: string;
- url: string;
sqProjectKey?: string;
+ url: string;
}
export interface GitlabProject {
name: string;
pathName: string;
pathSlug: string;
+ slug: string;
sqProjectKey?: string;
sqProjectName?: string;
- slug: string;
url: string;
}
export interface ProjectAlmBindingResponse {
alm: AlmKeys;
key: string;
+ monorepo: boolean;
repository: string;
slug?: string;
- url?: string;
summaryCommentEnabled?: boolean;
- monorepo: boolean;
+ url?: string;
}
export interface ProjectAzureBindingResponse extends ProjectAlmBindingResponse {
export interface ProjectAlmBindingParams {
almSetting: string;
- project: string;
monorepo: boolean;
+ project: string;
}
export interface AzureProjectAlmBindingParams extends ProjectAlmBindingParams {
}
export interface ProjectAlmBindingConfigurationErrors {
- scope: ProjectAlmBindingConfigurationErrorScope;
errors: { msg: string }[];
+ scope: ProjectAlmBindingConfigurationErrorScope;
}
export function isProjectBitbucketBindingResponse(
}
export interface ApplicationProject {
+ accessible?: boolean;
enabled?: boolean;
key: string;
name: string;
selected?: boolean;
- accessible?: boolean;
}
export interface ApplicationProjectBranch {
+ accessible?: boolean;
branch: string;
enabled?: boolean;
isMain: boolean;
key: string;
name: string;
selected?: boolean;
- accessible?: boolean;
}
authenticationError?: boolean;
authorizationError?: boolean;
canAdmin?: boolean;
+ documentationUrl: string;
edition?: EditionKey;
globalPages?: Extension[];
instanceUsesDefaultAdminCredentials?: boolean;
version: string;
versionEOL: string;
webAnalyticsJsPath?: string;
- documentationUrl: string;
}
declare module 'axios' {
export interface AxiosInstance {
- get<T = any>(url: string, config?: AxiosRequestConfig): Promise<T>;
+ defaults: Omit<AxiosDefaults, 'headers'> & {
+ headers: HeadersDefaults & {
+ [key: string]: AxiosHeaderValue;
+ };
+ };
delete<T = void>(url: string, config?: AxiosRequestConfig): Promise<T>;
- post<T = any, D = any>(url: string, data?: D, config?: AxiosRequestConfig<D>): Promise<T>;
+ get<T = any>(url: string, config?: AxiosRequestConfig): Promise<T>;
patch<T = any, D = Partial<OmitReadonly<T>>>(
url: string,
data?: D,
config?: AxiosRequestConfig<D>,
): Promise<T>;
- defaults: Omit<AxiosDefaults, 'headers'> & {
- headers: HeadersDefaults & {
- [key: string]: AxiosHeaderValue;
- };
- };
+ post<T = any, D = any>(url: string, data?: D, config?: AxiosRequestConfig<D>): Promise<T>;
}
}
}
export interface BranchLikeTree {
- mainBranchTree?: BranchTree;
branchTree: BranchTree[];
- parentlessPullRequests: PullRequest[];
+ mainBranchTree?: BranchTree;
orphanPullRequests: PullRequest[];
+ parentlessPullRequests: PullRequest[];
}
export interface BranchWithNewCodePeriod extends Branch {
export interface EnhancedWindow extends Window {
baseUrl: string;
- serverStatus: SysStatus;
instance: InstanceType;
official: boolean;
-
registerExtension: (key: string, start: ExtensionStartMethod, providesCSSFile?: boolean) => void;
+
+ serverStatus: SysStatus;
setWebAnalyticsPageChangeHandler: (pageHandler: (pathname: string) => void) => void;
t: (...keys: string[]) => string;
tp: (messageKey: string, ...parameters: Array<string | number>) => string;
export interface AppVariablesElement extends HTMLElement {
dataset: {
baseUrl: string;
- serverStatus: SysStatus;
instance: InstanceType;
official: string;
+ serverStatus: SysStatus;
};
}
}
export interface SoftwareImpact {
- softwareQuality: SoftwareQuality;
severity: SoftwareImpactSeverity;
+ softwareQuality: SoftwareQuality;
}
export interface SoftwareImpactMeasureData {
export interface SearchRulesResponse {
actives?: Dict<RuleActivation[]>;
facets?: { property: string; values: { count: number; val: string }[] }[];
- rules: Rule[];
paging: Paging;
+ rules: Rule[];
}
export interface ComponentContextShape {
component?: Component;
currentTask?: Task;
+ fetchComponent: () => Promise<void>;
isInProgress?: boolean;
isPending?: boolean;
onComponentChange: (changes: Partial<Component>) => void;
- fetchComponent: () => Promise<void>;
}
}
export interface License {
+ canActivateGracePeriod: boolean;
contactEmail: string;
edition: string;
expiresAt: string;
+ gracePeriodEndDate?: string;
+ gracePeriodExpired?: boolean;
isExpired: boolean;
isOfficialDistribution: boolean;
isSupported: boolean;
remainingLocThreshold: number;
serverId: string;
type: string;
- canActivateGracePeriod: boolean;
- gracePeriodEndDate?: string;
- gracePeriodExpired?: boolean;
}
}
export interface MessageFormatting {
- start: number;
end: number;
+ start: number;
type: MessageFormattingType;
}
export interface RawIssue {
actions: string[];
- transitions: IssueTransition[];
- tags?: string[];
assignee?: string;
author?: string;
- cleanCodeAttributeCategory: CleanCodeAttributeCategory;
cleanCodeAttribute: CleanCodeAttribute;
- impacts: SoftwareImpact[];
+ cleanCodeAttributeCategory: CleanCodeAttributeCategory;
codeVariants?: string[];
comments?: Comment[];
- creationDate: string;
component: string;
+ creationDate: string;
flows?: Array<{
- type?: string;
description?: string;
locations?: RawFlowLocation[];
+ type?: string;
}>;
+ impacts: SoftwareImpact[];
+ issueStatus: IssueStatus;
key: string;
line?: number;
+ message?: string;
messageFormattings?: MessageFormatting[];
prioritizedRule?: boolean;
project: string;
- rule: string;
+ quickFixAvailable?: boolean;
resolution?: string;
- message?: string;
+ rule: string;
+ ruleDescriptionContextKey?: string;
+ ruleStatus?: string;
+ scope: string;
severity: string;
status: string;
- issueStatus: IssueStatus;
+ tags?: string[];
textRange?: TextRange;
+ transitions: IssueTransition[];
type: IssueType;
- scope: string;
- ruleDescriptionContextKey?: string;
- ruleStatus?: string;
- quickFixAvailable?: boolean;
}
export interface IssueResponse {
}
export interface ReferencedComponent {
+ enabled?: boolean;
key: string;
+ longName?: string;
name: string;
path?: string;
- enabled?: boolean;
- longName?: string;
uuid: string;
}
export interface RawFacet {
property: string;
- values: Array<{ val: string; count: number }>;
+ values: Array<{ count: number; val: string }>;
}
export interface Facet {
}
export interface L10nBundle {
- timestamp?: string;
locale?: string;
messages?: Dict<string>;
+ timestamp?: string;
}
}
export interface NewCodeDefinition {
- projectKey?: string;
- type: NewCodeDefinitionType;
- value?: string;
effectiveValue?: string;
inherited?: boolean;
previousNonCompliantValue?: string;
+ projectKey?: string;
+ type: NewCodeDefinitionType;
updatedAt?: number;
+ value?: string;
}
export interface NewCodeDefinitiondWithCompliance {
+ isCompliant: boolean;
type?: NewCodeDefinitionType;
value?: string;
- isCompliant: boolean;
}
export interface NewCodeDefinitionBranch extends NewCodeDefinition {
- projectKey: string;
branchKey: string;
+ projectKey: string;
}
export interface AddRemoveNotificationParameters {
channel: string;
- type: string;
project?: string;
+ type: string;
}
* Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
*/
export interface Plugin {
- key: string;
- name: string;
category?: string;
description?: string;
editionBundled?: boolean;
+ homepageUrl?: string;
+ issueTrackerUrl?: string;
+ key: string;
license?: string;
+ name: string;
organizationName?: string;
- homepageUrl?: string;
organizationUrl?: string;
- issueTrackerUrl?: string;
termsAndConditionsUrl?: string;
}
export interface PendingPluginResult {
installing: PendingPlugin[];
- updating: PendingPlugin[];
removing: PendingPlugin[];
+ updating: PendingPlugin[];
}
export interface AvailablePlugin extends Plugin {
}
export interface PendingPlugin extends Plugin {
- version: string;
implementationBuild: string;
+ version: string;
}
export interface InstalledPlugin extends PendingPlugin {
documentationPath?: string;
- issueTrackerUrl?: string;
filename: string;
hash: string;
+ issueTrackerUrl?: string;
sonarLintSupported: boolean;
updatedAt: number;
updates?: Update[];
}
export interface Release {
- version: string;
+ changeLogUrl?: string;
date: string;
description?: string;
- changeLogUrl?: string;
+ version: string;
}
export interface Update {
- status: string;
+ previousUpdates?: Update[];
release?: Release;
requires: Plugin[];
- previousUpdates?: Update[];
+ status: string;
}
export enum PluginType {
export interface AnalysisEvent {
category: ProjectAnalysisEventCategory | ApplicationAnalysisEventCategory;
- description?: string;
- key: string;
- name: string;
- qualityGate?: {
- failing: Array<{ branch: string; key: string; name: string }>;
- status: Status;
- stillFailing: boolean;
- };
definitionChange?: {
projects: Array<{
branch?: string;
oldBranch?: string;
}>;
};
+ description?: string;
+ key: string;
+ name: string;
+ qualityGate?: {
+ failing: Array<{ branch: string; key: string; name: string }>;
+ status: Status;
+ stillFailing: boolean;
+ };
qualityProfile?: {
key: string;
languageKey: string;
}
export interface MeasureHistory {
- metric: MetricKey;
history: HistoryItem[];
+ metric: MetricKey;
}
export interface Serie {
export type GithubStatusDisabled = {
enabled: false;
- nextSync?: never;
lastSync?: never;
+ nextSync?: never;
};
export interface GithubStatusEnabled extends AlmSyncStatus {
enabled: true;
}
export interface AlmSyncStatus {
- nextSync?: { status: TaskStatuses.Pending | TaskStatuses.InProgress };
lastSync?: {
executionTimeMs: number;
finishedAt: number;
warningMessage?: string;
} & (
| {
+ errorMessage?: never;
status: TaskStatuses.Success;
summary?: string;
- errorMessage?: never;
}
| {
+ errorMessage?: string;
status: TaskStatuses.Canceled | TaskStatuses.Failed;
summary?: never;
- errorMessage?: string;
}
);
+ nextSync?: { status: TaskStatuses.Pending | TaskStatuses.InProgress };
}
export type GithubStatus = GithubStatusDisabled | GithubStatusEnabled;
type GitHubProvisioning =
| {
- status: GitHubProvisioningStatus.Success;
errorMessage?: never;
+ status: GitHubProvisioningStatus.Success;
}
| {
- status: GitHubProvisioningStatus.Failed;
errorMessage: string;
+ status: GitHubProvisioningStatus.Failed;
};
export interface GitHubConfigurationStatus {
application: {
- jit: GitHubProvisioning;
autoProvisioning: GitHubProvisioning;
+ jit: GitHubProvisioning;
};
installations: {
- organization: string;
- jit: GitHubProvisioning;
autoProvisioning: GitHubProvisioning;
+ jit: GitHubProvisioning;
+ organization: string;
}[];
}
export interface GitHubMapping {
- readonly id: string;
- readonly githubRole: string;
readonly baseRole?: boolean;
+ readonly githubRole: string;
+ readonly id: string;
permissions: {
- user: boolean;
+ admin: boolean;
codeViewer: boolean;
issueAdmin: boolean;
- securityHotspotAdmin: boolean;
- admin: boolean;
scan: boolean;
+ securityHotspotAdmin: boolean;
+ user: boolean;
};
}
export interface GitLabConfigurationCreateBody {
applicationId: string;
- url: string;
secret: string;
synchronizeGroups: boolean;
+ url: string;
}
export type GitLabConfigurationUpdateBody = {
+ allowUsersToSignUp?: boolean;
+ allowedGroups?: string[];
applicationId?: string;
- url?: string;
- secret?: string;
- synchronizeGroups?: boolean;
enabled?: boolean;
- provisioningType?: ProvisioningType;
provisioningToken?: string;
- allowedGroups?: string[];
- allowUsersToSignUp?: boolean;
+ provisioningType?: ProvisioningType;
+ secret?: string;
+ synchronizeGroups?: boolean;
+ url?: string;
};
export type GitlabConfiguration = {
- id: string;
- enabled: boolean;
- applicationId: string;
- synchronizeGroups: boolean;
- url: string;
- provisioningType: ProvisioningType;
- allowedGroups: string[];
allowUsersToSignUp: boolean;
+ allowedGroups: string[];
+ applicationId: string;
+ enabled: boolean;
errorMessage?: string;
+ id: string;
isProvisioningTokenSet: boolean;
+ provisioningType: ProvisioningType;
+ synchronizeGroups: boolean;
+ url: string;
};
export enum ProvisioningType {
import { UserBase } from './users';
export interface QualityGateProjectStatus {
+ caycStatus: CaycStatus;
conditions?: QualityGateProjectStatusCondition[];
ignoredConditions: boolean;
status: Status;
- caycStatus: CaycStatus;
}
export interface QualityGateProjectStatusCondition {
comparator: string;
errorThreshold?: string;
metric: string;
- periodIndex?: number;
onLeak?: boolean;
+ periodIndex?: number;
status: Status;
value: string;
warningThreshold?: string;
}
export interface QualityGateApplicationStatusChildProject {
+ caycStatus: CaycStatus;
conditions: QualityGateApplicationStatusCondition[];
key: string;
name: string;
status: Status;
- caycStatus: CaycStatus;
}
export interface QualityGateStatus {
+ branchLike?: BranchLike;
+ caycStatus: CaycStatus;
conditions: QualityGateStatusConditionEnhanced[];
failedConditions: QualityGateStatusConditionEnhanced[];
ignoredConditions?: boolean;
- caycStatus: CaycStatus;
key: string;
name: string;
status: Status;
- branchLike?: BranchLike;
}
export interface QualityGateStatusCondition {
cwe?: string;
f?: string;
facets?: string;
+ impactSeverities?: string;
+ impactSoftwareQualities?: string;
include_external?: boolean | string;
inheritance?: string;
is_template?: boolean | string;
owaspTop10?: string;
['owaspTop10-2021']?: string;
p?: number;
+ prioritizedRule?: boolean | string;
ps?: number;
q?: string;
qprofile?: string;
repositories?: string;
rule_key?: string;
s?: string;
- impactSoftwareQualities?: string;
- impactSeverities?: string;
sonarsourceSecurity?: string;
statuses?: string;
tags?: string;
template_key?: string;
types?: string;
- prioritizedRule?: boolean | string;
}
export enum RulesFacetName {
author?: string;
component: string;
creationDate: string;
+ flows?: Array<{
+ locations?: Array<Omit<FlowLocation, 'componentName'>>;
+ }>;
key: string;
line?: number;
message: string;
status: HotspotStatus;
updateDate: string;
vulnerabilityProbability: HotspotRatingEnum;
- flows?: Array<{
- locations?: Array<Omit<FlowLocation, 'componentName'>>;
- }>;
}
export interface Hotspot {
}
export interface HotspotComponent {
+ branch?: string;
key: string;
- qualifier: ComponentQualifier;
- name: string;
longName: string;
+ name: string;
path: string;
- branch?: string;
pullRequest?: string;
+ qualifier: ComponentQualifier;
}
export interface HotspotUpdateFields {
- status: HotspotStatus;
resolution?: HotspotResolution;
+ status: HotspotStatus;
}
export interface HotspotUpdate extends HotspotUpdateFields {
}
export interface HotspotComment {
- key: string;
+ createdAt: string;
htmlText: string;
+ key: string;
+ login: string;
markdown: string;
updatable: boolean;
- createdAt: string;
- login: string;
user: UserBase;
}
export interface ReviewHistoryElement {
- type: ReviewHistoryType;
date: string;
- user: Pick<UserBase, 'active' | 'avatar' | 'name'>;
diffs?: IssueChangelogDiff[];
html?: string;
key?: string;
- updatable?: boolean;
markdown?: string;
+ type: ReviewHistoryType;
+ updatable?: boolean;
+ user: Pick<UserBase, 'active' | 'avatar' | 'name'>;
}
export enum ReviewHistoryType {
}
export interface HotspotSearchResponse {
- components?: { key: string; qualifier: string; name: string }[];
+ components?: { key: string; name: string; qualifier: string }[];
hotspots: RawHotspot[];
paging: Paging;
}
export interface HotspotSetStatusRequest {
- status: HotspotStatus;
- resolution?: HotspotResolution;
comment?: string;
+ resolution?: HotspotResolution;
+ status: HotspotStatus;
}
export interface HotspotAssignRequest {
export type StandardType = SecurityStandard;
export type Standards = {
- [key in StandardType]: Dict<{ title: string; description?: string; level?: string }>;
+ [key in StandardType]: Dict<{ description?: string; level?: string; title: string }>;
};
}
export interface DefinitionV2 {
- name: string;
- key: string;
description?: string;
- secured: boolean;
+ key: string;
multiValues?: boolean;
+ name: string;
+ secured: boolean;
type?: SettingType;
}
export interface SettingValueResponse {
- settings: SettingValue[];
setSecuredSettings: string[];
+ settings: SettingValue[];
}
export interface SettingValue {
}
export interface MigrationsStatusResponse {
- status: MigrationStatus;
completedSteps?: number;
- totalSteps?: number;
- startedAt?: string;
- message?: string;
expectedFinishTimestamp?: string;
+ message?: string;
+ startedAt?: string;
+ status: MigrationStatus;
+ totalSteps?: number;
}
export interface Task {
analysisId?: string;
branch?: string;
- nodeName?: string;
componentKey?: string;
componentName?: string;
componentQualifier?: string;
hasErrorStacktrace?: boolean;
hasScannerContext?: boolean;
id: string;
+ infoMessages?: string[];
+ nodeName?: string;
pullRequest?: string;
pullRequestTitle?: string;
scannerContext?: string;
type: TaskTypes;
warningCount?: number;
warnings?: string[];
- infoMessages?: string[];
}
export interface TaskWarning {
+ dismissable: boolean;
key: string;
message: string;
- dismissable: boolean;
}
export interface ActivityRequestParameters {
component?: string;
+ maxExecutedAt?: string;
+ minSubmittedAt?: string;
+ onlyCurrents?: boolean;
p?: number;
ps?: number;
+ q?: string;
status?: string;
type?: string;
- onlyCurrents?: boolean;
- minSubmittedAt?: string;
- maxExecutedAt?: string;
- q?: string;
}
}
export interface UserToken {
- name: string;
createdAt: string;
- lastConnectionDate?: string;
expirationDate?: string;
isExpired: boolean;
+ lastConnectionDate?: string;
+ name: string;
+ project?: { key: string; name: string };
type: TokenType;
- project?: { name: string; key: string };
}
export interface NewUserToken extends UserToken {
}
export interface AlmRepository {
- label: string;
installationKey: string;
+ label: string;
linkedProjectKey?: string;
linkedProjectName?: string;
private?: boolean;
showBackgroundTasks?: boolean;
showHistory?: boolean;
showLinks?: boolean;
+ showPermissions?: boolean;
showQualityGates?: boolean;
showQualityProfiles?: boolean;
- showPermissions?: boolean;
showSettings?: boolean;
showUpdateKey?: boolean;
}
export interface ComponentMeasureIntern {
analysisDate?: string;
branch?: string;
+ canBrowseAllChildProjects?: boolean;
description?: string;
isFavorite?: boolean;
isRecentlyBrowsed?: boolean;
- canBrowseAllChildProjects?: boolean;
key: string;
match?: string;
name: string;
}
export interface ComponentMeasureEnhanced extends ComponentMeasureIntern {
- value?: string;
leak?: string;
measures: MeasureEnhanced[];
+ value?: string;
}
export interface Condition {
error: string;
id: string;
+ isCaycCondition?: boolean;
metric: string;
op?: string;
- isCaycCondition?: boolean;
}
export interface CustomMeasure {
description?: string;
id: string;
metric: {
+ domain?: string;
key: string;
name: string;
- domain?: string;
type: string;
};
- projectKey: string;
pending?: boolean;
+ projectKey: string;
+ updatedAt?: string;
user: UserBase;
value: string;
- updatedAt?: string;
}
export interface Duplication {
}
export interface Flow {
- type: FlowType;
description?: string;
locations: FlowLocation[];
+ type: FlowType;
}
export interface FlowLocation {
}
export interface Group {
- id: string;
default?: boolean;
- name: string;
description?: string;
+ id: string;
managed: boolean;
+ name: string;
}
export interface GroupMembership {
- id: string;
groupId: string;
+ id: string;
userId: string;
}
helpMessage?: string;
iconPath: string;
key: string;
- name: string;
manage?: boolean;
+ name: string;
}
export interface Issue extends Omit<RawIssue, 'flows' | 'comments'> {
componentUuid: string;
effort?: string;
externalRuleEngine?: string;
- fromExternalRule?: boolean;
flows: FlowLocation[][];
flowsWithType: Flow[];
+ fromExternalRule?: boolean;
message: string;
- projectName: string;
projectKey: string;
+ projectName: string;
pullRequest?: string;
ruleName: string;
secondaryLocations: FlowLocation[];
avatar?: string;
creationDate: string;
diffs: IssueChangelogDiff[];
- user: string;
+ externalUser?: string;
isUserActive: boolean;
+ user: string;
userName: string;
- externalUser?: string;
webhookSource?: string;
}
}
export interface MeasureEnhanced extends MeasureIntern {
- metric: Metric;
leak?: string;
+ metric: Metric;
}
export interface MeasureIntern {
key: string;
lastAnalysisDate?: string;
links: Array<{
+ href: string;
name: string;
type: string;
- href: string;
}>;
name: string;
qualityGate?: string;
}
export interface PermissionDefinition {
+ description: string;
key: string;
name: string;
- description: string;
}
export type PermissionDefinitions = Array<PermissionDefinition | PermissionDefinitionGroup>;
export interface PermissionGroup {
description?: string;
id?: string;
+ managed?: boolean;
name: string;
permissions: string[];
- managed?: boolean;
}
export interface PermissionUser extends UserActive {
- permissions: string[];
managed?: boolean;
+ permissions: string[];
}
export interface PermissionTemplateGroup {
+ groupsCount: number;
key: string;
usersCount: number;
- groupsCount: number;
withProjectCreator?: boolean;
}
export interface PermissionTemplate {
+ createdAt: string;
defaultFor: string[];
+ description?: string;
id: string;
name: string;
- description?: string;
+ permissions: Array<PermissionTemplateGroup>;
projectKeyPattern?: string;
- createdAt: string;
updatedAt?: string;
- permissions: Array<PermissionTemplateGroup>;
}
export interface ProfileInheritanceDetails {
rename?: boolean;
setAsDefault?: boolean;
};
+ caycStatus?: CaycStatus;
conditions?: Condition[];
isBuiltIn?: boolean;
- caycStatus?: CaycStatus;
}
export interface Rule {
- cleanCodeAttributeCategory?: CleanCodeAttributeCategory;
cleanCodeAttribute?: CleanCodeAttribute;
+ cleanCodeAttributeCategory?: CleanCodeAttributeCategory;
impacts: SoftwareImpact[];
isTemplate?: boolean;
key: string;
}
export interface RestRule {
- cleanCodeAttributeCategory?: CleanCodeAttributeCategory;
cleanCodeAttribute?: CleanCodeAttribute;
+ cleanCodeAttributeCategory?: CleanCodeAttributeCategory;
impacts: SoftwareImpact[];
- template?: boolean;
key: string;
language?: string;
languageName?: string;
status: string;
systemTags?: string[];
tags?: string[];
+ template?: boolean;
type: RuleType;
}
createdAt: string;
inherit: RuleInheritance;
params: { key: string; value: string }[];
- qProfile: string;
prioritizedRule: boolean;
+ qProfile: string;
severity: string;
}
createdAt: string;
descriptionSections?: RuleDescriptionSection[];
educationPrinciples?: string[];
+ external?: boolean;
gapDescription?: string;
htmlDesc?: string;
htmlNote?: string;
internalKey?: string;
- external?: boolean;
markdownDescription?: string;
markdownNote?: string;
remFnBaseEffort?: string;
export type RuleType = 'BUG' | 'VULNERABILITY' | 'CODE_SMELL' | 'SECURITY_HOTSPOT' | 'UNKNOWN';
export interface Snippet {
- start: number;
end: number;
index: number;
+ start: number;
toDelete?: boolean;
}
export type SourceLineCoverageStatus = 'uncovered' | 'partially-covered' | 'covered';
export interface SourceViewerFile {
+ canMarkAsFavorite?: boolean;
fav?: boolean;
key: string;
leakPeriodDate?: string;
+ longName?: string;
measures: {
coverage?: string;
duplicationDensity?: string;
lines?: string;
tests?: string;
};
- canMarkAsFavorite?: boolean;
- path: string;
name?: string;
- longName?: string;
+ path: string;
project: string;
projectName: string;
q: ComponentQualifier;
uuid: string;
}
-export type StandardSecurityCategories = Dict<{ title: string; description?: string }>;
+export type StandardSecurityCategories = Dict<{ description?: string; title: string }>;
export interface SubscriptionPlan {
maxNcloc: number;
ncloc: number;
};
System: {
+ 'External Users and Groups Provisioning'?: Provider;
'High Availability': true;
'Server ID': string;
Version: string;
- 'External Users and Groups Provisioning'?: Provider;
};
}
}
export interface TextRange {
- startLine: number;
- startOffset: number;
endLine: number;
endOffset: number;
+ startLine: number;
+ startOffset: number;
}
export interface UserSelected extends UserActive {
}
export interface UserGroupMember {
- selected: boolean;
login: string;
- name: string;
managed: boolean;
+ name: string;
+ selected: boolean;
}
export namespace WebApi {
export interface Action {
- key: string;
changelog: Changelog[];
- description: string;
deprecatedSince?: string;
+ description: string;
hasResponseExample: boolean;
internal: boolean;
+ key: string;
params?: Param[];
post: boolean;
since?: string;
exampleValue?: string;
internal: boolean;
key: string;
+ maxValuesAllowed?: number;
maximumLength?: number;
maximumValue?: number;
- maxValuesAllowed?: number;
minimumLength?: number;
minimumValue?: number;
possibleValues?: string[];
* Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
*/
export interface CurrentUser {
+ dismissedNotices: { [key: string]: boolean };
isLoggedIn: boolean;
permissions?: { global: string[] };
usingSonarLintConnectedMode?: boolean;
- dismissedNotices: { [key: string]: boolean };
}
export interface Notice {
}
export type HomePage =
- | { type: 'APPLICATION'; branch: string | undefined; component: string }
+ | { branch: string | undefined; component: string; type: 'APPLICATION' }
| { type: 'ISSUES' }
| { type: 'MY_ISSUES' }
| { type: 'MY_PROJECTS' }
- | { type: 'PORTFOLIO'; component: string }
+ | { component: string; type: 'PORTFOLIO' }
| { type: 'PORTFOLIOS' }
- | { type: 'PROJECT'; branch: string | undefined; component: string }
+ | { branch: string | undefined; component: string; type: 'PROJECT' }
| { type: 'PROJECTS' };
export interface CurrentUserSetting {
externalProvider?: string;
groups?: string[];
lastConnectionDate?: string;
- sonarLintLastConnectionDate?: string;
local: boolean;
managed: boolean;
scmAccounts?: string[];
+ sonarLintLastConnectionDate?: string;
tokensCount?: number;
}
}
export interface RestUser extends RestUserBase {
- email: string | null;
active: boolean;
- local: boolean;
- externalProvider: string;
avatar: string;
+ email: string | null;
+ externalProvider: string;
+ local: boolean;
}
export interface RestUserDetailed extends RestUser {
- managed: boolean;
externalLogin: string;
- sonarQubeLastConnectionDate: string | null;
- sonarLintLastConnectionDate: string | null;
+ managed: boolean;
scmAccounts: string[];
+ sonarLintLastConnectionDate: string | null;
+ sonarQubeLastConnectionDate: string | null;
}
export const enum ChangePasswordResults {
export type WebhookSearchDeliveriesPayload = {
ceTaskId?: string;
componentKey?: string;
- webhook?: string;
p?: number;
ps?: number;
+ webhook?: string;
};
eslint-plugin-react: "npm:7.33.2"
eslint-plugin-react-hooks: "npm:4.6.0"
eslint-plugin-testing-library: "npm:6.2.0"
+ eslint-plugin-typescript-sort-keys: "npm:3.2.0"
formik: "npm:2.4.5"
fs-extra: "npm:11.2.0"
http-proxy: "npm:1.18.1"
languageName: node
linkType: hard
+"eslint-plugin-typescript-sort-keys@npm:3.2.0":
+ version: 3.2.0
+ resolution: "eslint-plugin-typescript-sort-keys@npm:3.2.0"
+ dependencies:
+ "@typescript-eslint/experimental-utils": "npm:^5.0.0"
+ json-schema: "npm:^0.4.0"
+ natural-compare-lite: "npm:^1.4.0"
+ peerDependencies:
+ "@typescript-eslint/parser": ^6 || ^7
+ eslint: ^7 || ^8
+ typescript: ^3 || ^4 || ^5
+ checksum: 10/6ef3273ed1a0a1c60dd6750b4c9884f6c43668f552021d622492c26f2f2d8f7d86ca7f9fbfff23e3b756854bf1014e5f8e690eddccfb6ad569987b88650a9d55
+ languageName: node
+ linkType: hard
+
"eslint-scope@npm:^5.1.1":
version: 5.1.1
resolution: "eslint-scope@npm:5.1.1"
projects / sonarqube.git / commitdiff