@spinnaker/core 2026.2.2 → 2026.3.0

package/src/pipeline/config/templates/PipelineTemplateConfigurationAdapters.ts

@@ -0,0 +1,199 @@
+import { dump, load } from 'js-yaml';
+import { cloneDeep, has, omit } from 'lodash';
+
+import type { IPipelineTemplate, IPipelineTemplateConfig, IVariableMetadata } from './PipelineTemplateReader';
+import type { IPipeline, IPipelineTemplateConfigV2 } from '../../../domain';
+import type { IVariable } from './inputs/variableInput.service';
+import { PipelineTemplateV2Service } from './v2/pipelineTemplateV2.service';
+import { VariableValidatorService } from './validators/variableValidator.service';
+
+export interface ITemplateInheritance {
+  inheritTemplateExpectedArtifacts: boolean;
+  inheritTemplateNotifications: boolean;
+  inheritTemplateParameters: boolean;
+  inheritTemplateTriggers: boolean;
+}
+
+export interface IVariableMetadataGroup {
+  name: string;
+  variableMetadata: IVariableMetadata[];
+}
+
+export interface ITemplateConfigurationState {
+  inheritance: ITemplateInheritance;
+  isV2: boolean;
+  pipelineName: string;
+  source: string;
+  variableMetadataGroups: IVariableMetadataGroup[];
+  variables: IVariable[];
+}
+
+export function validateTemplateVariable(variable: IVariable, isV2: boolean): IVariable['errors'] {
+  if (!isV2 || variable.type !== 'object') {
+    return VariableValidatorService.validate(variable);
+  }
+  if (!variable.value) {
+    return [{ message: 'Field is required.' }];
+  }
+  try {
+    JSON.parse(variable.value);
+    return [];
+  } catch (_error) {
+    return [{ message: 'Value must be valid JSON.' }];
+  }
+}
+
+function groupVariableMetadata(variableMetadata: IVariableMetadata[]): IVariableMetadataGroup[] {
+  return variableMetadata.reduce((groups, metadata) => {
+    const groupName = metadata.group || 'Ungrouped';
+    const existing = groups.find((group) => group.name === groupName);
+    if (existing) {
+      existing.variableMetadata.push(metadata);
+    } else {
+      groups.push({ name: groupName, variableMetadata: [metadata] });
+    }
+    return groups;
+  }, [] as IVariableMetadataGroup[]);
+}
+
+function initialVariableValue(metadata: IVariableMetadata, values: Record<string, any>, isV2: boolean): any {
+  const hasConfiguredValue = has(values, metadata.name);
+  const value = hasConfiguredValue ? values[metadata.name] : metadata.defaultValue;
+  if (metadata.type === 'list' && !hasConfiguredValue && !has(metadata, 'defaultValue')) {
+    return [''];
+  }
+  if (metadata.type === 'object' && value !== undefined) {
+    return isV2 ? JSON.stringify(value) : dump(value);
+  }
+  return cloneDeep(value);
+}
+
+export function initializeTemplateConfiguration(
+  template: IPipelineTemplate,
+  pipelineTemplateConfig: IPipelineTemplateConfig | IPipelineTemplateConfigV2,
+): ITemplateConfigurationState {
+  const isV2 = PipelineTemplateV2Service.isV2PipelineConfig(pipelineTemplateConfig);
+  const v1Config = pipelineTemplateConfig as IPipelineTemplateConfig;
+  const v2Config = pipelineTemplateConfig as IPipelineTemplateConfigV2;
+  const metadata = template.variables || [];
+  const values = isV2 ? v2Config.variables || {} : v1Config.config?.pipeline.variables || {};
+  const variables = metadata.map((variableMetadata) => {
+    const variable: IVariable = {
+      name: variableMetadata.name,
+      type: variableMetadata.type || 'string',
+      value: initialVariableValue(variableMetadata, values, isV2),
+      errors: [],
+      hideErrors: true,
+    };
+    variable.errors = validateTemplateVariable(variable, isV2);
+    return variable;
+  });
+  const v1Inherit = v1Config.config?.configuration?.inherit || ['expectedArtifacts', 'parameters', 'triggers'];
+  const v2Exclude = v2Config.exclude || [];
+
+  return {
+    isV2,
+    pipelineName: isV2 ? v2Config.name : v1Config.config?.pipeline.name,
+    source: isV2 ? v2Config.template.reference : v1Config.config?.pipeline.template.source,
+    variableMetadataGroups: groupVariableMetadata(metadata),
+    variables,
+    inheritance: {
+      inheritTemplateExpectedArtifacts: isV2 || v1Inherit.includes('expectedArtifacts'),
+      inheritTemplateNotifications: isV2 && !v2Exclude.includes('notifications'),
+      inheritTemplateParameters: isV2 ? !v2Exclude.includes('parameters') : v1Inherit.includes('parameters'),
+      inheritTemplateTriggers: isV2 ? !v2Exclude.includes('triggers') : v1Inherit.includes('triggers'),
+    },
+  };
+}
+
+function transformVariables(state: ITemplateConfigurationState): Record<string, any> {
+  return state.variables.reduce((values, variable) => {
+    let value = cloneDeep(variable.value);
+    switch (variable.type) {
+      case 'boolean':
+        value = !!value;
+        break;
+      case 'object':
+        value = state.isV2 ? JSON.parse(value) : load(value);
+        break;
+      case 'int':
+        value = parseInt(value, 10);
+        break;
+      case 'float':
+        value = parseFloat(value);
+        break;
+    }
+    values[variable.name] = value;
+    return values;
+  }, {} as Record<string, any>);
+}
+
+export function buildTemplateConfig(
+  applicationName: string,
+  pipelineId: string,
+  pipelineTemplateConfig: IPipelineTemplateConfig | IPipelineTemplateConfigV2,
+  state: ITemplateConfigurationState,
+): IPipelineTemplateConfig | IPipelineTemplateConfigV2 {
+  const variables = transformVariables(state);
+  const { inheritance } = state;
+
+  if (!state.isV2) {
+    const inherit = [
+      ...(inheritance.inheritTemplateParameters ? ['parameters'] : []),
+      ...(inheritance.inheritTemplateExpectedArtifacts ? ['expectedArtifacts'] : []),
+      ...(inheritance.inheritTemplateTriggers ? ['triggers'] : []),
+    ];
+    return {
+      ...omit(pipelineTemplateConfig, ['triggers', 'parameterConfig', 'parameters', 'expectedArtifacts']),
+      type: 'templatedPipeline',
+      name: state.pipelineName,
+      application: applicationName,
+      config: {
+        schema: '1',
+        pipeline: {
+          name: state.pipelineName,
+          application: applicationName,
+          pipelineConfigId: pipelineId,
+          template: { source: state.source },
+          variables,
+        },
+        configuration: { inherit },
+      },
+    } as IPipelineTemplateConfig;
+  }
+
+  const exclude = [
+    ...(inheritance.inheritTemplateParameters ? [] : ['parameters']),
+    ...(inheritance.inheritTemplateNotifications ? [] : ['notifications']),
+    ...(inheritance.inheritTemplateTriggers ? [] : ['triggers']),
+  ];
+  return {
+    ...PipelineTemplateV2Service.filterInheritedConfig(cloneDeep(pipelineTemplateConfig)),
+    type: 'templatedPipeline',
+    name: state.pipelineName,
+    application: applicationName,
+    variables,
+    exclude,
+    ...PipelineTemplateV2Service.getPipelineTemplateConfigV2(state.source),
+  } as IPipelineTemplateConfigV2;
+}
+
+export function mergeTemplatePlan(
+  config: IPipelineTemplateConfig | IPipelineTemplateConfigV2,
+  plan: IPipeline,
+  state: ITemplateConfigurationState,
+): IPipeline {
+  const { inheritance } = state;
+  return {
+    ...config,
+    ...(inheritance.inheritTemplateParameters && plan.parameterConfig ? { parameterConfig: plan.parameterConfig } : {}),
+    ...(state.isV2 && inheritance.inheritTemplateNotifications && plan.notifications
+      ? { notifications: plan.notifications }
+      : {}),
+    ...(!state.isV2 && inheritance.inheritTemplateExpectedArtifacts && plan.expectedArtifacts
+      ? { expectedArtifacts: plan.expectedArtifacts }
+      : {}),
+    ...(state.isV2 && plan.expectedArtifacts ? { expectedArtifacts: plan.expectedArtifacts } : {}),
+    ...(inheritance.inheritTemplateTriggers && plan.triggers ? { triggers: plan.triggers } : {}),
+  } as IPipeline;
+}

package/src/pipeline/config/templates/PipelineTemplateReader.ts

@@ -1,5 +1,4 @@
 import { flatten } from 'lodash';
-import { $q } from 'ngimport';
 
 import { REST } from '../../../api/ApiService';
 import type { IPipelineTemplateConfigV2 } from '../../../domain';
@@ -84,7 +83,7 @@ export class PipelineTemplateReader {
     source: string,
     executionId?: string,
     pipelineConfigId?: string,
-  ): PromiseLike<IPipelineTemplate> {
+  ): Promise<IPipelineTemplate> {
     return REST('/pipelineTemplates/resolve')
       .query({ source, executionId, pipelineConfigId })
       .get()
@@ -97,20 +96,19 @@ export class PipelineTemplateReader {
   public static getPipelinePlan(
     config: IPipelineTemplateConfig | IPipelineTemplateConfigV2,
     executionId?: string,
-  ): PromiseLike<IPipeline> {
+  ): Promise<IPipeline> {
     const endpoint = PipelineTemplateV2Service.isV2PipelineConfig(config)
       ? '/v2/pipelineTemplates/plan'
       : '/pipelines/start';
     return REST(endpoint).post({ ...config, plan: true, executionId });
   }
 
-  public static getPipelineTemplatesByScope = (scope: string): PromiseLike<IPipelineTemplate[]> => {
+  public static getPipelineTemplatesByScope = (scope: string): Promise<IPipelineTemplate[]> => {
     return REST('/pipelineTemplates').query({ scope }).get();
   };
 
-  public static getPipelineTemplatesByScopes(scopes: string[]): PromiseLike<IPipelineTemplate[]> {
-    return $q
-      .all(scopes.map(this.getPipelineTemplatesByScope))
+  public static getPipelineTemplatesByScopes(scopes: string[]): Promise<IPipelineTemplate[]> {
+    return Promise.all(scopes.map(this.getPipelineTemplatesByScope))
       .then((templates) => flatten(templates))
       .then((templates) => {
         templates.forEach((template) => (template.selfLink = `spinnaker://${template.id}`));
@@ -139,7 +137,7 @@ export class PipelineTemplateReader {
     };
   }
 
-  public static getV2PipelineTemplateList(): PromiseLike<IPipelineTemplateV2Collections> {
+  public static getV2PipelineTemplateList(): Promise<IPipelineTemplateV2Collections> {
     return REST('/v2/pipelineTemplates/versions').get();
   }
 }

package/src/pipeline/config/templates/PipelineTemplateWriter.ts

@@ -1,16 +1,12 @@
-import { $q } from 'ngimport';
-
 import { REST } from '../../../api/ApiService';
 import type { IPipelineTemplateV2 } from '../../../domain/IPipelineTemplateV2';
 
 export class PipelineTemplateWriter {
-  public static savePipelineTemplateV2(template: IPipelineTemplateV2): PromiseLike<any> {
-    return $q((resolve, reject) => {
-      REST('/v2/pipelineTemplates/create').post(template).then(resolve, reject);
-    });
+  public static savePipelineTemplateV2(template: IPipelineTemplateV2): Promise<any> {
+    return REST('/v2/pipelineTemplates/create').post(template);
   }
 
-  public static deleteTemplate(template: { id: string; digest?: string; tag?: string }): PromiseLike<any> {
+  public static deleteTemplate(template: { id: string; digest?: string; tag?: string }): Promise<any> {
     let request = REST('/v2/pipelineTemplates').path(template.id);
 
     const params: { digest?: string; tag?: string } = {};

package/src/pipeline/config/templates/Variable.spec.tsx

@@ -1,4 +1,3 @@
-import { mock } from 'angular';
 import type { ReactWrapper } from 'enzyme';
 import { mount } from 'enzyme';
 import React from 'react';
@@ -6,8 +5,6 @@ import React from 'react';
 import type { VariableType } from './PipelineTemplateReader';
 import { Variable } from './Variable';
 import type { IVariableError, IVariableProps } from './inputs/variableInput.service';
-import { PIPELINE_TEMPLATE_MODULE } from './pipelineTemplate.module';
-import { REACT_MODULE } from '../../../reactShims/react.module';
 
 describe('Variable component', () => {
   const generateProps = (type: VariableType, value: any) => {
@@ -26,10 +23,6 @@ describe('Variable component', () => {
     };
   };
 
-  beforeEach(mock.module(PIPELINE_TEMPLATE_MODULE, REACT_MODULE));
-
-  beforeEach(mock.inject(() => {})); // Angular is lazy.
-
   describe('input fields', () => {
     let component: ReactWrapper<IVariableProps, null>;
     beforeEach(() => {

package/src/pipeline/config/templates/index.ts

@@ -1,2 +1,4 @@
+export * from './ConfigurePipelineTemplateModal';
+export * from './PipelineTemplateConfigurationAdapters';
 export * from './v2/pipelineTemplateV2.service';
 export * from './PipelineTemplateReader';

package/src/pipeline/config/templates/templateVariableRegistrations.ts

@@ -0,0 +1,9 @@
+import './inputs/BooleanInput';
+import './inputs/ListInput';
+import './inputs/NumberInput';
+import './inputs/ObjectInput';
+import './inputs/StringInput';
+import './validators/list.validator';
+import './validators/number.validator';
+import './validators/object.validator';
+import './validators/string.validator';

package/src/pipeline/config/templates/v2/PipelineTemplatesV2.spec.tsx

@@ -0,0 +1,57 @@
+import { shallow } from 'enzyme';
+import React from 'react';
+
+import { PipelineTemplatesV2Component } from './PipelineTemplatesV2';
+import { PipelineTemplateReader } from '../PipelineTemplateReader';
+
+describe('PipelineTemplatesV2', () => {
+  it('initializes the selected template from injected route params', () => {
+    const component = shallow(
+      <PipelineTemplatesV2Component
+        {...({
+          router: {},
+          stateParams: { templateId: 'injected-template' },
+          stateService: {},
+        } as any)}
+      />,
+      { disableLifecycleMethods: true },
+    );
+
+    expect(component.state('viewTemplateVersion')).toBe('injected-template');
+  });
+
+  it('dismisses template details through the injected state service', () => {
+    const injectedGo = jasmine.createSpy('injectedGo');
+    const component = shallow(
+      <PipelineTemplatesV2Component {...({ router: {}, stateParams: {}, stateService: { go: injectedGo } } as any)} />,
+      { disableLifecycleMethods: true },
+    );
+
+    (component.instance() as any).dismissDetailsModal();
+
+    expect(injectedGo).toHaveBeenCalledWith('home.pipeline-templates');
+  });
+
+  it('observes route changes through the injected router', () => {
+    const injectedUnsubscribe = jasmine.createSpy('injectedUnsubscribe');
+    const injectedOnSuccess = jasmine.createSpy('injectedOnSuccess').and.returnValue(injectedUnsubscribe);
+    spyOn(PipelineTemplateReader, 'getV2PipelineTemplateList').and.returnValue(Promise.resolve({}));
+    const component = shallow(
+      <PipelineTemplatesV2Component
+        {...({
+          router: { transitionService: { onSuccess: injectedOnSuccess } },
+          stateParams: {},
+          stateService: {},
+        } as any)}
+      />,
+      { disableLifecycleMethods: true },
+    );
+    const instance = component.instance() as PipelineTemplatesV2Component;
+
+    instance.componentDidMount();
+    instance.componentWillUnmount();
+
+    expect(injectedOnSuccess).toHaveBeenCalledWith({}, jasmine.any(Function));
+    expect(injectedUnsubscribe).toHaveBeenCalled();
+  });
+});

package/src/pipeline/config/templates/v2/PipelineTemplatesV2.tsx

@@ -14,10 +14,10 @@ import type {
   IPipelineTemplateV2Collections,
   IPipelineTemplateV2VersionSelections,
 } from '../../../../domain/IPipelineTemplateV2';
+import type { IRouterInjectedProps, IRouterStateChange } from '../../../../navigation/routerContext';
+import { stateChangeSuccess$, withRouter } from '../../../../navigation/routerContext';
 import { PipelineTemplateV2Service } from './pipelineTemplateV2.service';
 import { ReactSelectInput } from '../../../../presentation';
-import type { IStateChange } from '../../../../reactShims';
-import { ReactInjector } from '../../../../reactShims';
 
 import './PipelineTemplatesV2.less';
 
@@ -42,7 +42,7 @@ export const PipelineTemplatesV2Error = (props: { message: string }) => {
   );
 };
 
-export class PipelineTemplatesV2 extends React.Component<{}, IPipelineTemplatesV2State> {
+export class PipelineTemplatesV2Component extends React.Component<IRouterInjectedProps, IPipelineTemplatesV2State> {
   private routeChangedSubscription: Subscription = null;
 
   public state: IPipelineTemplatesV2State = {
@@ -50,13 +50,13 @@ export class PipelineTemplatesV2 extends React.Component<{}, IPipelineTemplatesV
     searchValue: '',
     selectedTemplate: null,
     templates: {},
-    viewTemplateVersion: ReactInjector.$stateParams.templateId,
+    viewTemplateVersion: this.props.stateParams.templateId,
     templateVersionSelections: {},
   };
 
   public componentDidMount() {
     this.fetchTemplates();
-    this.routeChangedSubscription = ReactInjector.stateEvents.stateChangeSuccess.subscribe(this.onRouteChanged);
+    this.routeChangedSubscription = stateChangeSuccess$(this.props.router).subscribe(this.onRouteChanged);
   }
 
   public componentWillUnmount() {
@@ -77,7 +77,7 @@ export class PipelineTemplatesV2 extends React.Component<{}, IPipelineTemplatesV
     );
   }
 
-  private onRouteChanged = (stateChange: IStateChange) => {
+  private onRouteChanged = (stateChange: IRouterStateChange) => {
     const { to, toParams } = stateChange;
     if (to.name === 'home.pipeline-templates') {
       this.setState({ viewTemplateVersion: null });
@@ -112,7 +112,7 @@ export class PipelineTemplatesV2 extends React.Component<{}, IPipelineTemplatesV
   };
 
   private dismissDetailsModal = () => {
-    ReactInjector.$state.go('home.pipeline-templates');
+    this.props.stateService.go('home.pipeline-templates');
   };
 
   private onSearchFieldChanged = (event: React.SyntheticEvent<HTMLInputElement>) => {
@@ -313,3 +313,5 @@ export class PipelineTemplatesV2 extends React.Component<{}, IPipelineTemplatesV
     );
   }
 }
+
+export const PipelineTemplatesV2 = withRouter(PipelineTemplatesV2Component);

package/src/pipeline/config/templates/v2/createPipelineFromTemplate/CreatePipelineFromTemplate.spec.tsx

@@ -0,0 +1,28 @@
+import { shallow } from 'enzyme';
+import React from 'react';
+
+import { CreatePipelineFromTemplateComponent } from './CreatePipelineFromTemplate';
+import { CreatePipelineModal } from '../../../../create';
+
+describe('CreatePipelineFromTemplate', () => {
+  it('opens a saved pipeline through the injected state service', () => {
+    const injectedGo = jasmine.createSpy('injectedGo');
+    const component = shallow(
+      <CreatePipelineFromTemplateComponent
+        {...({ router: {}, stateParams: {}, stateService: { go: injectedGo } } as any)}
+        closeModalCallback={() => undefined}
+        template={{} as any}
+      />,
+      { disableLifecycleMethods: true },
+    );
+    component.setState({ applicationSelectionComplete: true, loadedApplication: { name: 'test-app' } });
+
+    (component.find(CreatePipelineModal).prop('pipelineSavedCallback') as (id: string) => void)('pipeline-id');
+
+    expect(injectedGo).toHaveBeenCalledWith('home.applications.application.pipelines.pipelineConfig', {
+      application: 'test-app',
+      pipelineId: 'pipeline-id',
+      new: 1,
+    });
+  });
+});

package/src/pipeline/config/templates/v2/createPipelineFromTemplate/CreatePipelineFromTemplate.tsx

@@ -10,7 +10,8 @@ import { ApplicationReader } from '../../../../../application';
 import { CreatePipelineModal } from '../../../../create';
 import type { IPipelineTemplateV2 } from '../../../../../domain/IPipelineTemplateV2';
 import { SubmitButton } from '../../../../../modal/buttons/SubmitButton';
-import { ReactInjector } from '../../../../../reactShims';
+import type { IRouterInjectedProps } from '../../../../../navigation/routerContext';
+import { withRouter } from '../../../../../navigation/routerContext';
 import { Spinner } from '../../../../../widgets/spinners/Spinner';
 
 import './createPipelineFromTemplate.less';
@@ -30,8 +31,8 @@ interface ICreatePipelineFromTemplateState {
   submitting: boolean;
 }
 
-export class CreatePipelineFromTemplate extends React.Component<
-  ICreatePipelineFromTemplateProps,
+export class CreatePipelineFromTemplateComponent extends React.Component<
+  ICreatePipelineFromTemplateProps & IRouterInjectedProps,
   ICreatePipelineFromTemplateState
 > {
   public state: ICreatePipelineFromTemplateState = {
@@ -101,8 +102,11 @@ export class CreatePipelineFromTemplate extends React.Component<
   };
 
   private goToPipelineConfig = (application: string, id: string) => {
-    const { $state } = ReactInjector;
-    $state.go('home.applications.application.pipelines.pipelineConfig', { application, pipelineId: id, new: 1 });
+    this.props.stateService.go('home.applications.application.pipelines.pipelineConfig', {
+      application,
+      pipelineId: id,
+      new: 1,
+    });
   };
 
   public render() {
@@ -168,3 +172,5 @@ export class CreatePipelineFromTemplate extends React.Component<
     );
   }
 }
+
+export const CreatePipelineFromTemplate = withRouter(CreatePipelineFromTemplateComponent);

package/src/pipeline/config/templates/v2/pipelineTemplateV2.states.ts

@@ -1,41 +1,34 @@
-import { module } from 'angular';
-
 import { PipelineTemplatesV2 } from './PipelineTemplatesV2';
-import type { INestedState, StateConfigProvider } from '../../../../navigation';
-import { STATE_CONFIG_PROVIDER } from '../../../../navigation';
-
-export const PIPELINE_TEMPLATES_V2_STATES_CONFIG = 'spinnaker.core.pipeline.templates.v2.states.config';
+import type { INestedState } from '../../../../navigation';
+import { registerRootState } from '../../../../navigation/rootState.registration';
 
-module(PIPELINE_TEMPLATES_V2_STATES_CONFIG, [STATE_CONFIG_PROVIDER]).config([
-  'stateConfigProvider',
-  (stateConfigProvider: StateConfigProvider) => {
-    const pipelineTemplateDetail: INestedState = {
-      name: 'pipeline-templates-detail',
-      url: '/:templateId',
-      data: {
-        pageTitleMain: {
-          label: 'Pipeline Templates',
-        },
+registerRootState((stateConfigProvider) => {
+  const pipelineTemplateDetail: INestedState = {
+    name: 'pipeline-templates-detail',
+    url: '/:templateId',
+    data: {
+      pageTitleMain: {
+        label: 'Pipeline Templates',
       },
-    };
+    },
+  };
 
-    const pipelineTemplatesList: INestedState = {
-      name: 'pipeline-templates',
-      url: '/pipeline-templates',
-      views: {
-        'main@': {
-          component: PipelineTemplatesV2,
-          $type: 'react',
-        },
+  const pipelineTemplatesList: INestedState = {
+    name: 'pipeline-templates',
+    url: '/pipeline-templates',
+    views: {
+      'main@': {
+        component: PipelineTemplatesV2,
+        $type: 'react',
       },
-      data: {
-        pageTitleMain: {
-          label: 'Pipeline Templates',
-        },
+    },
+    data: {
+      pageTitleMain: {
+        label: 'Pipeline Templates',
       },
-      children: [pipelineTemplateDetail],
-    };
+    },
+    children: [pipelineTemplateDetail],
+  };
 
-    stateConfigProvider.addToRootState(pipelineTemplatesList);
-  },
-]);
+  stateConfigProvider.addToRootState(pipelineTemplatesList);
+});

package/src/pipeline/config/triggers/Triggers.tsx

@@ -8,7 +8,6 @@ import { TriggersPageContent } from './TriggersPageContent';
 import type { Application } from '../../../application';
 import type { IPipeline } from '../../../domain';
 import { PageNavigator, PageSection } from '../../../presentation';
-import { ReactInjector } from '../../../reactShims/react.injector';
 
 export interface ITriggersProps {
   application: Application;
@@ -26,7 +25,7 @@ export function Triggers(props: ITriggersProps) {
   const revertCountKLUDGE = props.revertCount;
 
   return (
-    <PageNavigator scrollableContainer="[ui-view]" reactInjector={ReactInjector}>
+    <PageNavigator scrollableContainer=".pipeline-config-page">
       <PageSection pageKey="concurrent" label="Execution Options" visible={!pipeline.strategy}>
         <ExecutionOptionsPageContent {...props} />
       </PageSection>

package/src/pipeline/config/triggers/artifactory/artifactoryReader.service.ts

@@ -1,7 +1,7 @@
 import { REST } from '../../../../api/ApiService';
 
 export class ArtifactoryReaderService {
-  public static getArtifactoryNames(): PromiseLike<string[]> {
+  public static getArtifactoryNames(): Promise<string[]> {
     return REST('/artifactory/names').get();
   }
 }

package/src/pipeline/config/triggers/artifacts/ArtifactService.ts

@@ -1,18 +1,18 @@
 import { REST } from '../../../../api/ApiService';
 
 export class ArtifactService {
-  public static getArtifactNames(type: string, accountName: string): PromiseLike<string[]> {
+  public static getArtifactNames(type: string, accountName: string): Promise<string[]> {
     return REST('/artifacts/account').path(accountName, 'names').query({ type: type }).get();
   }
 
-  public static getArtifactVersions(type: string, accountName: string, artifactName: string): PromiseLike<string[]> {
+  public static getArtifactVersions(type: string, accountName: string, artifactName: string): Promise<string[]> {
     return REST('/artifacts/account')
       .path(accountName, 'versions')
       .query({ type: type, artifactName: artifactName })
       .get();
   }
 
-  public static getArtifactByContentReference(contentRef: string): PromiseLike<{ reference: string }> {
+  public static getArtifactByContentReference(contentRef: string): Promise<{ reference: string }> {
     return REST(`/artifacts/content-address/${contentRef}`).get();
   }
 }