@spinnaker/cloudrun 2026.2.3 → 2026.3.0

package/src/serverGroup/configure/wizard/serverGroupWizard.tsx

@@ -1,7 +1,22 @@
 import React from 'react';
-import type { Application, IModalComponentProps, IStage } from '@spinnaker/core';
-//import type { IModalInstanceService } from 'angular-ui-bootstrap';
-import { noop, ReactInjector, ReactModal, TaskMonitor, WizardModal, WizardPage } from '@spinnaker/core';
+
+import type {
+  Application,
+  DeckRuntimeServices,
+  IModalComponentProps,
+  IRouterInjectedProps,
+  IStage,
+} from '@spinnaker/core';
+import {
+  DeckRuntimeContext,
+  noop,
+  ReactModal,
+  TaskMonitor,
+  withRouter,
+  WizardModal,
+  WizardPage,
+} from '@spinnaker/core';
+
 import { WizardServerGroupBasicSettings } from './BasicSettings';
 import { WizardServerGroupConfigFilesSettings } from './ConfigFiles';
 import type { ICloudrunServerGroupCommandData } from '../serverGroupCommandBuilder.service';
@@ -12,6 +27,8 @@ export interface ICloudrunServerGroupModalProps extends IModalComponentProps {
   application: Application;
   command: ICloudrunServerGroupCommandData;
   isNew?: boolean;
+  closeModal?: (command: any) => void;
+  dismissModal?: () => void;
 }
 
 export interface ICloudrunServerGroupModalState {
@@ -20,21 +37,31 @@ export interface ICloudrunServerGroupModalState {
   taskMonitor: TaskMonitor;
 }
 
-export class ServerGroupWizard extends React.Component<ICloudrunServerGroupModalProps, ICloudrunServerGroupModalState> {
-  public static defaultProps: Partial<ICloudrunServerGroupModalProps> = {
+export class ServerGroupWizardComponent extends React.Component<
+  ICloudrunServerGroupModalProps & IRouterInjectedProps,
+  ICloudrunServerGroupModalState
+> {
+  public static contextType = DeckRuntimeContext;
+  public declare context: React.ContextType<typeof DeckRuntimeContext>;
+
+  public static defaultProps: Partial<ICloudrunServerGroupModalProps & IRouterInjectedProps> = {
     closeModal: noop,
     dismissModal: noop,
   };
 
   private _isUnmounted = false;
+  private applicationRefreshUnsubscribe?: () => void;
 
   /*     private serverGroupWriter: ServerGroupWriter; */
-  public static show(props: ICloudrunServerGroupModalProps): Promise<ICloudrunServerGroupCommandData> {
+  public static show(
+    props: ICloudrunServerGroupModalProps,
+    runtimeServices: DeckRuntimeServices,
+  ): Promise<ICloudrunServerGroupCommandData> {
     const modalProps = { dialogClassName: 'wizard-modal modal-lg' };
-    return ReactModal.show(ServerGroupWizard, props, modalProps);
+    return ReactModal.show(ServerGroupWizard, props, modalProps, runtimeServices);
   }
 
-  constructor(props: ICloudrunServerGroupModalProps) {
+  constructor(props: ICloudrunServerGroupModalProps & IRouterInjectedProps) {
     super(props);
     if (!props.command) {
       CloudrunServerGroupCommandBuilder.buildNewServerGroupCommand(props.application, 'cloudrun', 'create').then(
@@ -53,18 +80,20 @@ export class ServerGroupWizard extends React.Component<ICloudrunServerGroupModal
         title: `${
           props.command.command.viewState.submitButtonLabel === 'Create' ? 'Creating' : 'Updating'
         } your Server Group`,
-        modalInstance: TaskMonitor.modalInstanceEmulation(() => this.props.dismissModal()),
+        onDismiss: () => this.props.dismissModal(),
         onTaskComplete: this.onTaskComplete,
       }),
     };
   }
 
   private onTaskComplete = () => {
+    this.clearApplicationRefreshSubscription();
+    this.applicationRefreshUnsubscribe = this.props.application.serverGroups.onNextRefresh(this.onApplicationRefresh);
     this.props.application.serverGroups.refresh();
-    this.props.application.serverGroups.onNextRefresh(null, this.onApplicationRefresh);
   };
 
   protected onApplicationRefresh = (): void => {
+    this.clearApplicationRefreshSubscription();
     if (this._isUnmounted) {
       return;
     }
@@ -82,23 +111,33 @@ export class ServerGroupWizard extends React.Component<ICloudrunServerGroupModal
           provider: 'cloudrun',
         };
         let transitionTo = '^.^.^.clusters.serverGroup';
-        if (ReactInjector.$state.includes('**.clusters.serverGroup')) {
+        if (this.props.stateService.includes('**.clusters.serverGroup')) {
           // clone via details, all view
           transitionTo = '^.serverGroup';
         }
-        if (ReactInjector.$state.includes('**.clusters.cluster.serverGroup')) {
+        if (this.props.stateService.includes('**.clusters.cluster.serverGroup')) {
           // clone or create with details open
           transitionTo = '^.^.serverGroup';
         }
-        if (ReactInjector.$state.includes('**.clusters')) {
+        if (this.props.stateService.includes('**.clusters')) {
           // create new, no details open
           transitionTo = '.serverGroup';
         }
-        ReactInjector.$state.go(transitionTo, newStateParams);
+        this.props.stateService.go(transitionTo, newStateParams);
       }
     }
   };
 
+  public componentWillUnmount(): void {
+    this._isUnmounted = true;
+    this.clearApplicationRefreshSubscription();
+  }
+
+  private clearApplicationRefreshSubscription = (): void => {
+    this.applicationRefreshUnsubscribe?.();
+    this.applicationRefreshUnsubscribe = undefined;
+  };
+
   private submit = (c: ICloudrunServerGroupCommandData): void => {
     const command: any = CloudrunServerGroupCommandBuilder.copyAndCleanCommand(c.command);
     const forPipelineConfig = command.viewState.mode === 'editPipeline' || command.viewState.mode === 'createPipeline';
@@ -106,7 +145,8 @@ export class ServerGroupWizard extends React.Component<ICloudrunServerGroupModal
       this.props.closeModal && this.props.closeModal(command);
     } else {
       //command.viewState.mode = 'create';
-      const submitMethod = () => ReactInjector.serverGroupWriter.cloneServerGroup(command, this.props.application);
+      const submitMethod = () =>
+        this.context.services.serverGroupWriter.cloneServerGroup(command, this.props.application);
       this.state.taskMonitor.submit(submitMethod);
       return null;
     }
@@ -148,3 +188,7 @@ export class ServerGroupWizard extends React.Component<ICloudrunServerGroupModal
     );
   }
 }
+
+export const ServerGroupWizard = Object.assign(withRouter(ServerGroupWizardComponent), {
+  show: ServerGroupWizardComponent.show,
+});

package/src/serverGroup/details/CloudrunServerGroupActions.tsx

@@ -0,0 +1,80 @@
+import React from 'react';
+import { Dropdown, MenuItem } from 'react-bootstrap';
+
+import type { IRouterInjectedProps, IServerGroupActionsProps } from '@spinnaker/core';
+import { ConfirmationModalService, useDeckRuntimeServices, withRouter } from '@spinnaker/core';
+
+import { CloudrunHealth } from '../../common/cloudrunHealth';
+import type { ICloudrunServerGroup } from '../../interfaces';
+
+export function CloudrunServerGroupActionsComponent({
+  app,
+  serverGroup,
+  stateService,
+}: IServerGroupActionsProps & IRouterInjectedProps) {
+  const { serverGroupWriter } = useDeckRuntimeServices();
+  const cloudrunServerGroup = serverGroup as ICloudrunServerGroup;
+  const canDestroyServerGroup = Boolean(
+    cloudrunServerGroup && !cloudrunServerGroup.tags?.isLatest && cloudrunServerGroup.disabled,
+  );
+  const destroyServerGroup = () => {
+    const stateParams = {
+      name: cloudrunServerGroup.name,
+      accountId: cloudrunServerGroup.account,
+      region: cloudrunServerGroup.region,
+    };
+    const taskMonitor = {
+      application: app,
+      title: `Destroying ${cloudrunServerGroup.name}`,
+      onTaskComplete: () => {
+        if (stateService.includes('**.serverGroup', stateParams)) {
+          stateService.go('^');
+        }
+      },
+    };
+    const confirmationModalParams = {
+      header: `Really destroy ${cloudrunServerGroup.name}?`,
+      buttonText: `Destroy ${cloudrunServerGroup.name}`,
+      account: cloudrunServerGroup.account,
+      taskMonitorConfig: taskMonitor,
+      submitMethod: (params: any) => serverGroupWriter.destroyServerGroup(cloudrunServerGroup, app, params),
+      askForReason: true,
+      platformHealthOnlyShowOverride: app.attributes.platformHealthOnlyShowOverride,
+      platformHealthType: CloudrunHealth.PLATFORM,
+      interestingHealthProviderNames: [] as string[],
+    };
+
+    if (app.attributes.platformHealthOnlyShowOverride && app.attributes.platformHealthOnly) {
+      confirmationModalParams.interestingHealthProviderNames = [CloudrunHealth.PLATFORM];
+    }
+
+    ConfirmationModalService.confirm(confirmationModalParams);
+  };
+
+  return (
+    <Dropdown className="dropdown" id="cloudrun-server-group-actions-dropdown">
+      <Dropdown.Toggle className="btn btn-sm btn-primary dropdown-toggle">Server Group Actions</Dropdown.Toggle>
+      <Dropdown.Menu>
+        {cloudrunServerGroup.tags?.isLatest && (
+          <MenuItem
+            disabled={true}
+            title="You cannot destroy the latest server group (revision). You may be able to delete this server group's load balancer."
+          >
+            Destroy
+          </MenuItem>
+        )}
+        {canDestroyServerGroup && <MenuItem onClick={destroyServerGroup}>Destroy</MenuItem>}
+        {!canDestroyServerGroup && !cloudrunServerGroup.tags?.isLatest && (
+          <MenuItem
+            disabled={true}
+            title="You cannot destroy this server group while it is receiving traffic. You may be able to delete this server group's load balancer."
+          >
+            Destroy
+          </MenuItem>
+        )}
+      </Dropdown.Menu>
+    </Dropdown>
+  );
+}
+
+export const CloudrunServerGroupActions = withRouter(CloudrunServerGroupActionsComponent);

package/src/serverGroup/details/cloudrunServerGroupDetailsGetter.spec.ts

@@ -0,0 +1,46 @@
+import { ServerGroupReader } from '@spinnaker/core';
+
+import { cloudrunServerGroupDetailsGetter } from './cloudrunServerGroupDetailsGetter';
+
+describe('cloudrunServerGroupDetailsGetter', () => {
+  const props: any = {
+    app: {
+      name: 'fnord',
+      serverGroups: { data: [] },
+      loadBalancers: { data: [] },
+    },
+    serverGroup: {
+      name: 'service-v000',
+      accountId: 'test',
+      region: 'us-central1',
+    },
+  };
+
+  it('auto-closes and completes when server group lookup fails', (done) => {
+    const autoClose = jasmine.createSpy('autoClose');
+    spyOn(ServerGroupReader, 'getServerGroup').and.returnValue(Promise.reject(new Error('not found')) as any);
+
+    cloudrunServerGroupDetailsGetter(props, autoClose).subscribe({
+      next: () => fail('should not emit a server group'),
+      error: () => fail('should not emit an error'),
+      complete: () => {
+        expect(autoClose).toHaveBeenCalled();
+        done();
+      },
+    });
+  });
+
+  it('auto-closes and completes when lookup returns no server group', (done) => {
+    const autoClose = jasmine.createSpy('autoClose');
+    spyOn(ServerGroupReader, 'getServerGroup').and.returnValue(Promise.resolve(null) as any);
+
+    cloudrunServerGroupDetailsGetter(props, autoClose).subscribe({
+      next: () => fail('should not emit a server group'),
+      error: () => fail('should not emit an error'),
+      complete: () => {
+        expect(autoClose).toHaveBeenCalled();
+        done();
+      },
+    });
+  });
+});

package/src/serverGroup/details/cloudrunServerGroupDetailsGetter.ts

@@ -0,0 +1,53 @@
+import { isEmpty } from 'lodash';
+import { Observable } from 'rxjs';
+
+import type { IServerGroup, IServerGroupDetailsProps } from '@spinnaker/core';
+import { ServerGroupReader } from '@spinnaker/core';
+
+export const cloudrunServerGroupDetailsGetter = (
+  props: IServerGroupDetailsProps,
+  autoClose: () => void,
+): Observable<IServerGroup> => {
+  const { app, serverGroup } = props;
+  return new Observable<IServerGroup>((observer) => {
+    ServerGroupReader.getServerGroup(app.name, serverGroup.accountId, serverGroup.region, serverGroup.name).then(
+      (serverGroupDetails: IServerGroup) => {
+        let fromApp = app.serverGroups.data.find((toCheck: IServerGroup) => {
+          return (
+            toCheck.name === serverGroup.name &&
+            toCheck.account === serverGroup.accountId &&
+            toCheck.region === serverGroup.region
+          );
+        });
+
+        if (!fromApp) {
+          app.loadBalancers.data.some((loadBalancer: any) => {
+            if (loadBalancer.account !== serverGroup.accountId) {
+              return false;
+            }
+            return loadBalancer.serverGroups.some((toCheck: IServerGroup) => {
+              if (toCheck.name === serverGroup.name) {
+                fromApp = toCheck;
+                return true;
+              }
+              return false;
+            });
+          });
+        }
+
+        const mergedServerGroup = { ...serverGroupDetails, ...fromApp };
+        if (isEmpty(mergedServerGroup)) {
+          autoClose();
+          observer.complete();
+          return;
+        }
+
+        observer.next(mergedServerGroup);
+      },
+      () => {
+        autoClose();
+        observer.complete();
+      },
+    );
+  });
+};

package/src/serverGroup/details/sections.tsx

@@ -0,0 +1,60 @@
+import React from 'react';
+
+import type { IServerGroupDetailsSectionProps } from '@spinnaker/core';
+import { AccountTag, CollapsibleSection, HealthCounts, timestamp } from '@spinnaker/core';
+
+export function CloudrunServerGroupInformationSection({ serverGroup }: IServerGroupDetailsSectionProps) {
+  return (
+    <CollapsibleSection heading="Server Group Information" defaultExpanded={true}>
+      <dl className="dl-horizontal dl-narrow">
+        <dt>Created</dt>
+        <dd>{timestamp(serverGroup.createdTime)}</dd>
+        <dt>In</dt>
+        <dd>
+          <AccountTag account={serverGroup.account} />
+        </dd>
+        <dt>Region</dt>
+        <dd>{serverGroup.region}</dd>
+      </dl>
+    </CollapsibleSection>
+  );
+}
+
+export function CloudrunServerGroupSizeSection({ serverGroup }: IServerGroupDetailsSectionProps) {
+  const capacity = serverGroup.capacity || ({} as any);
+  const current = serverGroup.instances?.length || 0;
+  return (
+    <CollapsibleSection heading="Size" defaultExpanded={true}>
+      <dl className="dl-horizontal dl-narrow">
+        {capacity.min === capacity.max ? (
+          <>
+            <dt>Min/Max</dt>
+            <dd>{capacity.min}</dd>
+          </>
+        ) : (
+          <>
+            <dt>Min</dt>
+            <dd>{capacity.min}</dd>
+            <dt>Max</dt>
+            <dd>{capacity.max}</dd>
+          </>
+        )}
+        <dt>Current</dt>
+        <dd>{current}</dd>
+      </dl>
+    </CollapsibleSection>
+  );
+}
+
+export function CloudrunServerGroupHealthSection({ serverGroup }: IServerGroupDetailsSectionProps) {
+  return (
+    <CollapsibleSection heading="Health" defaultExpanded={true}>
+      <dl className="dl-horizontal dl-narrow">
+        <dt>Instances</dt>
+        <dd>
+          <HealthCounts container={serverGroup.instanceCounts} className="pull-left" />
+        </dd>
+      </dl>
+    </CollapsibleSection>
+  );
+}

package/src/serverGroup/index.ts

@@ -1,3 +1,5 @@
 export * from './configure/serverGroupCommandBuilder.service';
 export * from './serverGroupTransformer.service';
-export * from './details/details.controller';
+export * from './details/CloudrunServerGroupActions';
+export * from './details/cloudrunServerGroupDetailsGetter';
+export * from './details/sections';

package/src/serverGroup/routerConsumers.spec.tsx

@@ -0,0 +1,152 @@
+import { mount, shallow } from 'enzyme';
+import React from 'react';
+import { MenuItem } from 'react-bootstrap';
+
+import { ConfirmationModalService, DeckRuntimeContext, ServerGroupNamePreview } from '@spinnaker/core';
+
+import { ServerGroupBasicSettingsComponent } from './configure/wizard/BasicSettings';
+import { ServerGroupWizardComponent } from './configure/wizard/serverGroupWizard';
+import { CloudrunServerGroupActionsComponent } from './details/CloudrunServerGroupActions';
+
+describe('Cloud Run server group router consumers', () => {
+  it('opens the latest server group through the injected state service', () => {
+    const go = jasmine.createSpy('go');
+    const component = shallow(
+      <ServerGroupBasicSettingsComponent
+        {...({ router: {}, stateParams: {}, stateService: { go, is: () => true } } as any)}
+        accounts={[]}
+        app={
+          {
+            clusters: [],
+            name: 'app',
+            serverGroups: {
+              data: [{ account: 'test', cluster: 'app-main', createdTime: 1, name: 'app-main-v001', region: 'us' }],
+            },
+          } as any
+        }
+        detailsChanged={() => undefined}
+        formik={
+          {
+            values: {
+              command: {
+                credentials: 'test',
+                region: 'us',
+                selectedProvider: 'cloudrun',
+                viewState: { mode: 'create' },
+              },
+              stack: 'main',
+            },
+          } as any
+        }
+        onAccountSelect={() => undefined}
+        onEnterStack={() => undefined}
+        selectedAccount="test"
+      />,
+    );
+
+    component.find(ServerGroupNamePreview).prop('navigateToLatestServerGroup')();
+
+    expect(go).toHaveBeenCalledWith('.serverGroup', {
+      accountId: 'test',
+      provider: 'cloudrun',
+      region: 'us',
+      serverGroup: 'app-main-v001',
+    });
+  });
+
+  it('closes destroyed server group details through the injected state service', () => {
+    const go = jasmine.createSpy('go');
+    const confirm = spyOn(ConfirmationModalService, 'confirm');
+    const component = mount(
+      <DeckRuntimeContext.Provider value={{ services: { serverGroupWriter: {} } } as any}>
+        <CloudrunServerGroupActionsComponent
+          {...({ router: {}, stateParams: {}, stateService: { go, includes: () => true } } as any)}
+          app={{ attributes: {} } as any}
+          serverGroup={
+            {
+              account: 'test',
+              disabled: true,
+              name: 'app-v001',
+              region: 'us',
+              tags: { isLatest: false },
+            } as any
+          }
+        />
+      </DeckRuntimeContext.Provider>,
+    );
+
+    component.find(MenuItem).first().prop('onClick')();
+    confirm.calls.mostRecent().args[0].taskMonitorConfig.onTaskComplete();
+
+    expect(go).toHaveBeenCalledWith('^');
+  });
+
+  it('opens a newly created server group through the injected state service', () => {
+    const go = jasmine.createSpy('go');
+    const component = new ServerGroupWizardComponent({
+      application: { serverGroups: {} },
+      closeModal: () => undefined,
+      command: {
+        command: { credentials: 'test', region: 'us', viewState: { submitButtonLabel: 'Create' } },
+      },
+      dismissModal: () => undefined,
+      router: {},
+      stateParams: {},
+      stateService: { go, includes: (state: string) => state === '**.clusters' },
+      title: 'Create server group',
+    } as any);
+    component.state.taskMonitor = {
+      task: {
+        execution: {
+          stages: [{ context: { 'deploy.server.groups': { us: 'app-v001' } }, type: 'cloneServerGroup' }],
+        },
+      },
+    } as any;
+
+    (component as any).onApplicationRefresh();
+
+    expect(go).toHaveBeenCalledWith('.serverGroup', {
+      accountId: 'test',
+      provider: 'cloudrun',
+      region: 'us',
+      serverGroup: 'app-v001',
+    });
+  });
+
+  it('owns the server group refresh subscription across replacement and unmount', () => {
+    const firstUnsubscribe = jasmine.createSpy('firstUnsubscribe');
+    const secondUnsubscribe = jasmine.createSpy('secondUnsubscribe');
+    const callbacks: Array<() => void> = [];
+    const onNextRefresh = jasmine.createSpy('onNextRefresh').and.callFake((callback: () => void) => {
+      callbacks.push(callback);
+      return callbacks.length === 1 ? firstUnsubscribe : secondUnsubscribe;
+    });
+    const refresh = jasmine.createSpy('refresh');
+    const go = jasmine.createSpy('go');
+    const component = new ServerGroupWizardComponent({
+      application: { serverGroups: { onNextRefresh, refresh } },
+      closeModal: jasmine.createSpy('closeModal'),
+      command: { command: { credentials: 'test', region: 'us', viewState: { submitButtonLabel: 'Create' } } },
+      dismissModal: jasmine.createSpy('dismissModal'),
+      router: {},
+      stateParams: {},
+      stateService: { go, includes: () => false },
+      title: 'Create server group',
+    } as any) as any;
+
+    component.onTaskComplete();
+
+    expect(onNextRefresh.calls.first().invocationOrder).toBeLessThan(refresh.calls.first().invocationOrder);
+
+    component.onTaskComplete();
+
+    expect(firstUnsubscribe).toHaveBeenCalledTimes(1);
+
+    component.componentWillUnmount();
+    callbacks[1]();
+
+    expect(secondUnsubscribe).toHaveBeenCalledTimes(1);
+    expect(component.applicationRefreshUnsubscribe).toBeUndefined();
+    expect(go).not.toHaveBeenCalled();
+  });
+});

package/src/serverGroup/serverGroupTransformer.service.ts

@@ -1,14 +1,10 @@
-import { module } from 'angular';
 import type { IServerGroup } from '@spinnaker/core';
 
 import type { ICloudrunServerGroupCommand } from '../serverGroup/configure/serverGroupCommandBuilder.service';
 
 export class CloudrunV2ServerGroupTransformer {
-  public static $inject = ['$q'];
-  constructor(private $q: ng.IQService) {}
-
-  public normalizeServerGroup(serverGroup: IServerGroup): PromiseLike<IServerGroup> {
-    return this.$q.resolve(serverGroup);
+  public normalizeServerGroup(serverGroup: IServerGroup): Promise<IServerGroup> {
+    return Promise.resolve(serverGroup);
   }
 
   public convertServerGroupCommandToDeployConfiguration(command: ICloudrunServerGroupCommand): any {
@@ -53,9 +49,3 @@ export class CloudrunDeployDescription {
     this.configArtifacts = [];
   }
 }
-
-export const CLOUDRUN_SERVER_GROUP_TRANSFORMER = 'spinnaker.cloudrun.serverGroup.transformer.service';
-module(CLOUDRUN_SERVER_GROUP_TRANSFORMER, []).service(
-  'cloudrunV2ServerGroupTransformer',
-  CloudrunV2ServerGroupTransformer,
-);

package/dist/common/componentUrlDetails.component.d.ts

@@ -1 +0,0 @@
-export declare const CLOUDRUN_COMPONENT_URL_DETAILS = "spinnaker.cloudrun.componentUrlDetails.component";

package/dist/common/conditionalDescriptionListItem.component.d.ts

@@ -1 +0,0 @@
-export declare const CLOUDRUN_CONDITIONAL_DESCRIPTION_LIST_ITEM = "spinnaker.cloudrun.conditionalDescriptionListItem";

package/dist/common/loadBalancerMessage.component.d.ts

@@ -1 +0,0 @@
-export declare const CLOUDRUN_LOAD_BALANCER_CREATE_MESSAGE = "spinnaker.cloudrun.loadBalancer.createMessage.component";

package/dist/instance/details/details.controller.d.ts

@@ -1 +0,0 @@
-export declare const CLOUDRUN_INSTANCE_DETAILS_CTRL = "spinnaker.cloudrun.instanceDetails.controller";

package/dist/loadBalancer/configure/wizard/allocationConfigurationRow.component.d.ts

@@ -1 +0,0 @@
-export declare const CLOUDRUN_ALLOCATION_CONFIGURATION_ROW = "spinnaker.cloudrun.allocationConfigurationRow.component";

package/dist/loadBalancer/configure/wizard/basicSettings.component.d.ts

@@ -1 +0,0 @@
-export declare const CLOUDRUN_LOAD_BALANCER_BASIC_SETTINGS = "spinnaker.cloudrun.loadBalancerSettings.component";

package/dist/loadBalancer/configure/wizard/stageAllocationConfigurationRow.component.d.ts

@@ -1 +0,0 @@
-export declare const CLOUDRUN_STAGE_ALLOCATION_CONFIGURATION_ROW = "spinnaker.cloudrun.stageAllocationConfigurationRow.component";

package/dist/loadBalancer/configure/wizard/wizard.controller.d.ts

@@ -1,2 +0,0 @@
-import './wizard.less';
-export declare const CLOUDRUN_LOAD_BALANCER_WIZARD_CTRL = "spinnaker.cloudrun.loadBalancer.wizard.controller";

package/dist/loadBalancer/details/details.controller.d.ts

@@ -1 +0,0 @@
-export declare const CLOUDRUN_LOAD_BALANCER_DETAILS_CTRL = "spinnaker.cloudrun.loadBalancerDetails.controller";

package/dist/pipeline/pipeline.module.d.ts

@@ -1 +0,0 @@
-export declare const CLOUDRUN_PIPELINE_MODULE = "spinnaker.cloudrun.pipeline.module";

package/dist/pipeline/stages/editLoadBalancer/loadBalancerChoice.modal.controller.d.ts

@@ -1 +0,0 @@
-export declare const CLOUDRUN_LOAD_BALANCER_CHOICE_MODAL_CTRL = "spinnaker.Cloudrun.loadBalancerChoiceModal.controller";

package/dist/serverGroup/details/details.controller.d.ts

@@ -1 +0,0 @@
-export declare const CLOUDRUN_SERVER_GROUP_DETAILS_CTRL = "spinnaker.cloudrun.serverGroup.details.controller";

package/src/common/componentUrlDetails.component.ts

@@ -1,22 +0,0 @@
-import type { IComponentOptions } from 'angular';
-import { module } from 'angular';
-
-const cloudrunComponentUrlDetailsComponent: IComponentOptions = {
-  bindings: { component: '<' },
-  template: `
-    <dt>HTTPS</dt>
-    <dl class="small">
-      <a href="{{$ctrl.component.url}}" target="_blank">{{$ctrl.component.url}}</a>
-      <copy-to-clipboard class="copy-to-clipboard copy-to-clipboard-sm"
-                         tool-tip="'Copy URL to clipboard'"
-                         text="$ctrl.component.httpsUrl"></copy-to-clipboard>
-    </dl>
-  `,
-};
-
-export const CLOUDRUN_COMPONENT_URL_DETAILS = 'spinnaker.cloudrun.componentUrlDetails.component';
-
-module(CLOUDRUN_COMPONENT_URL_DETAILS, []).component(
-  'cloudrunComponentUrlDetails',
-  cloudrunComponentUrlDetailsComponent,
-);