@spinnaker/core 2025.0.5 → 2025.1.0

package/src/projects/ProjectHeader.tsx

@@ -10,7 +10,6 @@ import { ConfigureProjectModal } from './configure/ConfigureProjectModal';
 import type { IProject } from '../domain';
 import { Overridable } from '../overrideRegistry';
 import { SpanDropdownTrigger } from '../presentation';
-import { ReactInjector } from '../reactShims';
 
 import './project.less';
 
@@ -47,16 +46,20 @@ export class ProjectHeader extends React.Component<IProjectHeaderProps, IProject
 
   private configureProject = () => {
     const { projectConfiguration } = this.props;
-    const { $state } = ReactInjector;
+    const $state = this.props.transition.router.stateService;
     const title = 'Configure project';
 
-    ConfigureProjectModal.show({ title, projectConfiguration }).then((result) => {
-      if (result.action === 'delete') {
-        $state.go('home.infrastructure');
-      } else if (result.action === 'upsert') {
-        $state.go($state.current, { project: result.name }, { location: 'replace', reload: true });
-      }
-    });
+    ConfigureProjectModal.show({ title, projectConfiguration })
+      .then((result) => {
+        if (result.action === 'delete') {
+          $state.go('home.infrastructure');
+        } else if (result.action === 'upsert') {
+          $state.go($state.current, { project: result.name }, { location: 'replace', reload: true });
+        }
+      })
+      .catch((err) => {
+        console.error(err);
+      });
   };
 
   public render() {

package/src/projects/Projects.spec.tsx

@@ -0,0 +1,141 @@
+import type { UIRouterReact } from '@uirouter/react';
+import { mock } from 'angular';
+import type { ReactWrapper } from 'enzyme';
+import * as React from 'react';
+import { act } from 'react-dom/test-utils';
+
+import { Projects } from './Projects';
+import { ViewStateCache } from '../cache';
+import { OVERRIDE_REGISTRY } from '../overrideRegistry';
+import { REACT_MODULE } from '../reactShims';
+import * as ProjectReaderModule from './service/ProjectReader';
+import { timestamp } from '../utils';
+import { mountAndFlush } from '../utils/testUtils';
+
+type TestProject = ReturnType<typeof makeProject>;
+
+const makeProject = (name: string, email: string, createTs: number, updateTs: number) => ({
+  id: name,
+  name,
+  email,
+  createTs,
+  updateTs,
+  config: { pipelineConfigs: [], applications: [], clusters: [] },
+  lastModifiedBy: 'anonymous',
+});
+
+const deck = makeProject('deck', 'a@netflix.com', new Date(2).getTime(), new Date(2).getTime());
+const oort = makeProject('oort', 'b@netflix.com', new Date(3).getTime(), new Date(3).getTime());
+const mort = makeProject('mort', 'c@netflix.com', new Date(1).getTime(), new Date(1).getTime());
+const projectList: TestProject[] = [deck, oort, mort];
+
+const getRenderedNames = (wrapper: ReactWrapper) => wrapper.find('tbody tr').map((r) => r.find('td a').first().text());
+
+export function invokeSort(toggle: ReactWrapper<any>, next: string) {
+  const onChange = toggle.prop('onChange') as (v: string) => void;
+  onChange(next);
+}
+
+describe('Projects', () => {
+  let $uiRouter: UIRouterReact;
+  let listSpy: jasmine.Spy;
+
+  beforeEach(mock.module(REACT_MODULE, OVERRIDE_REGISTRY));
+  beforeEach(
+    mock.inject((_$uiRouter_: UIRouterReact) => {
+      $uiRouter = _$uiRouter_;
+    }),
+  );
+
+  describe('filtering & sorting', () => {
+    beforeEach(() => {
+      listSpy = spyOn(ProjectReaderModule.ProjectReader, 'listProjects').and.returnValue(Promise.resolve(projectList));
+    });
+
+    afterEach(() => {
+      ViewStateCache.clearCache('projects');
+    });
+
+    it('sets loaded flag and renders projects sorted by name asc', async () => {
+      const wrapper = await mountAndFlush(<Projects />);
+
+      const rows = wrapper.find('tbody tr');
+      expect(rows.length).toBe(3);
+
+      expect(getRenderedNames(wrapper)).toEqual(['deck', 'mort', 'oort']);
+
+      const firstRowTds = rows.at(0).find('td');
+      expect(firstRowTds.at(1).text()).toContain(timestamp(new Date(2).getTime())); // createTs
+      expect(firstRowTds.at(2).text()).toContain(timestamp(new Date(2).getTime())); // updateTs
+      expect(firstRowTds.at(3).text()).toBe('a@netflix.com');
+    });
+
+    it('filters by name or email as the user types', async () => {
+      const wrapper = await mountAndFlush(<Projects />);
+
+      const input = wrapper.find('input[placeholder="Search projects"]');
+      expect(input.exists()).toBeTrue();
+
+      // Filter by email
+      await act(async () => {
+        input.prop('onChange')?.({ target: { value: 'a@netflix.com' } } as any);
+      });
+      wrapper.update();
+      let rows = wrapper.find('tbody tr');
+      expect(rows.length).toBe(1);
+      expect(rows.at(0).find('td a').text()).toBe('deck');
+
+      // Filter by substring 'ort'
+      await act(async () => {
+        input.prop('onChange')?.({ target: { value: 'ort' } } as any);
+      });
+      wrapper.update();
+      rows = wrapper.find('tbody tr');
+      expect(rows.map((r) => r.find('td a').text())).toEqual(['mort', 'oort']);
+
+      // Clear
+      await act(async () => {
+        input.prop('onChange')?.({ target: { value: '' } } as any);
+      });
+      wrapper.update();
+      expect(wrapper.find('tbody tr').length).toBe(3);
+    });
+
+    it('sorts by -name, -createTs, createTs, and combines with a filter', async () => {
+      const wrapper = await mountAndFlush(<Projects />);
+
+      const sortToggles = wrapper.find('SortToggle');
+
+      // -name (desc)
+      const nameToggle = sortToggles.filterWhere((n) => n.prop('label') === 'Name').first();
+      await act(async () => {
+        invokeSort(nameToggle, '-name');
+      });
+      wrapper.update();
+      expect(getRenderedNames(wrapper)).toEqual(['oort', 'mort', 'deck']);
+
+      // -createTs (desc)
+      const createdToggle = sortToggles.filterWhere((n) => n.prop('label') === 'Created').first();
+      await act(async () => {
+        invokeSort(createdToggle, '-createTs');
+      });
+      wrapper.update();
+      expect(getRenderedNames(wrapper)).toEqual(['oort', 'deck', 'mort']);
+
+      // -createTs (asc)
+      await act(async () => {
+        invokeSort(createdToggle, 'createTs');
+      });
+      wrapper.update();
+      expect(getRenderedNames(wrapper)).toEqual(['mort', 'deck', 'oort']);
+
+      // Add filter ("ort") while sorted by createTs
+      const input = wrapper.find('input[placeholder="Search projects"]');
+      await act(async () => {
+        input.prop('onChange')?.({ target: { value: 'ort' } } as any);
+      });
+      wrapper.update();
+      expect(getRenderedNames(wrapper)).toEqual(['mort', 'oort']);
+    });
+  });
+});

package/src/projects/Projects.tsx

@@ -0,0 +1,148 @@
+import { UISref } from '@uirouter/react';
+import { orderBy } from 'lodash';
+import React, { useEffect, useMemo, useRef, useState } from 'react';
+import type { SelectCallback } from 'react-bootstrap';
+
+import { PaginationControls } from '../application/search/PaginationControls';
+import { ViewStateCache } from '../cache';
+import type { IProject } from '../domain';
+import { InsightMenu } from '../insight/InsightMenu';
+import { SortToggle } from '../presentation';
+import { anyFieldFilter } from '../presentation/anyFieldFilter/anyField.filter';
+import { ProjectReader } from './service/ProjectReader';
+import { timestamp } from '../utils';
+import { Spinner } from '../widgets';
+
+interface IProjectSummary extends IProject {
+  createTs?: number;
+  updateTs?: number;
+  email: string;
+}
+
+interface IProjectsViewState {
+  projectFilter: string;
+  sort: string;
+}
+
+export const Projects = () => {
+  const cache = useRef(ViewStateCache.get('projects') || ViewStateCache.createCache('projects', { version: 1 }))
+    .current;
+  const cached: IProjectsViewState = cache.get('#global') || { projectFilter: '', sort: 'name' };
+
+  const [projects, setProjects] = useState<IProjectSummary[]>([]);
+  const [loaded, setLoaded] = useState(false);
+  const [projectFilter, setProjectFilter] = useState<string>(cached.projectFilter);
+  const [sortKey, setSortKey] = useState<string>(cached.sort);
+  const [currentPage, setCurrentPage] = useState(1);
+  const inputRef = useRef<HTMLInputElement>();
+
+  useEffect(() => {
+    cache.put('#global', { projectFilter, sort: sortKey });
+  }, [projectFilter, sortKey, cache]);
+
+  useEffect(() => {
+    ProjectReader.listProjects().then((result: IProjectSummary[]) => {
+      setProjects(result);
+      setLoaded(true);
+    });
+  }, []);
+
+  useEffect(() => {
+    inputRef.current?.focus();
+  }, []);
+
+  useEffect(() => {
+    setCurrentPage(1);
+  }, [projectFilter, sortKey]);
+
+  const filteredProjects = useMemo(() => {
+    const filterFn = anyFieldFilter();
+    const filtered = filterFn(projects, {
+      name: projectFilter,
+      email: projectFilter,
+    });
+    const key = sortKey?.startsWith('-') ? sortKey.slice(1) : sortKey;
+    const direction = sortKey?.startsWith('-') ? 'desc' : 'asc';
+    return orderBy(filtered, [key], [direction]);
+  }, [projects, projectFilter, sortKey]);
+
+  const itemsPerPage = 12;
+  const totalPages = Math.ceil(filteredProjects.length / itemsPerPage) || 1;
+  const pageProjects = filteredProjects.slice((currentPage - 1) * itemsPerPage, currentPage * itemsPerPage);
+
+  const changePage: SelectCallback = (page: any) => setCurrentPage(Number(page));
+
+  const Loading = () => (
+    <div className="horizontal center middle" style={{ marginBottom: '250px', height: '100px' }}>
+      <Spinner size="small" />
+    </div>
+  );
+
+  return (
+    <div className="infrastructure">
+      <div className="infrastructure-section search-header">
+        <div className="container">
+          <h2 className="header-section">
+            <span className="search-label">Projects</span>
+            <input
+              type="search"
+              placeholder="Search projects"
+              className="form-control input-md"
+              ref={inputRef}
+              value={projectFilter}
+              onChange={(e) => setProjectFilter(e.target.value)}
+            />
+          </h2>
+          <div className="header-actions">
+            <InsightMenu createApp={false} createProject={true} refreshCaches={false} />
+          </div>
+        </div>
+      </div>
+      <div className="container">
+        {!loaded && <Loading />}
+        {loaded && (
+          <>
+            <table className="table table-hover">
+              <thead>
+                <tr>
+                  <th style={{ width: '20%' }}>
+                    <SortToggle currentSort={sortKey} onChange={setSortKey} label="Name" sortKey="name" />
+                  </th>
+                  <th style={{ width: '20%' }}>
+                    <SortToggle currentSort={sortKey} onChange={setSortKey} label="Created" sortKey="createTs" />
+                  </th>
+                  <th style={{ width: '20%' }}>
+                    <SortToggle currentSort={sortKey} onChange={setSortKey} label="Updated" sortKey="updateTs" />
+                  </th>
+                  <th style={{ width: '25%' }}>
+                    <SortToggle currentSort={sortKey} onChange={setSortKey} label="Owner" sortKey="email" />
+                  </th>
+                </tr>
+              </thead>
+              <tbody>
+                {pageProjects.map((project) => {
+                  const projectName = project.name.toLowerCase();
+                  return (
+                    <UISref key={projectName} to="home.project.dashboard" params={{ project: projectName }}>
+                      <tr className="clickable">
+                        <td>
+                          <UISref to="home.project.dashboard" params={{ project: projectName }}>
+                            <a>{projectName}</a>
+                          </UISref>
+                        </td>
+                        <td>{timestamp(project.createTs)}</td>
+                        <td>{timestamp(project.updateTs)}</td>
+                        <td>{project.email}</td>
+                      </tr>
+                    </UISref>
+                  );
+                })}
+              </tbody>
+            </table>
+            <PaginationControls onPageChanged={changePage} activePage={currentPage} totalPages={totalPages} />
+          </>
+        )}
+      </div>
+    </div>
+  );
+};

package/src/projects/index.ts

@@ -3,3 +3,4 @@ export * from './ProjectHeader';
 export * from './projectSearchResultType';
 export * from './service/ProjectReader';
 export * from './service/ProjectWriter';
+export * from './Projects';

package/src/projects/{projects.module.js → projects.module.ts}

@@ -1,5 +1,3 @@
-'use strict';
-
 import { module } from 'angular';
 
 import './projectSearchResultType';

package/src/projects/projects.states.ts

@@ -2,13 +2,13 @@ import type { StateParams } from '@uirouter/angularjs';
 import { module } from 'angular';
 
 import { ProjectHeader } from './ProjectHeader';
+import { Projects } from './Projects';
 import type { ApplicationStateProvider } from '../application/application.state.provider';
 import { APPLICATION_STATE_PROVIDER } from '../application/application.state.provider';
 import { CORE_PROJECTS_DASHBOARD_DASHBOARD_CONTROLLER } from './dashboard/dashboard.controller';
 import type { IProject } from '../domain/IProject';
 import type { INestedState, StateConfigProvider } from '../navigation/state.provider';
 import { STATE_CONFIG_PROVIDER } from '../navigation/state.provider';
-import { CORE_PROJECTS_PROJECTS_CONTROLLER } from './projects.controller';
 import { ProjectReader } from './service/ProjectReader';
 
 export interface IProjectStateParms extends StateParams {
@@ -17,7 +17,6 @@ export interface IProjectStateParms extends StateParams {
 
 export const PROJECTS_STATES_CONFIG = 'spinnaker.core.projects.state.config';
 module(PROJECTS_STATES_CONFIG, [
-  CORE_PROJECTS_PROJECTS_CONTROLLER,
   CORE_PROJECTS_DASHBOARD_DASHBOARD_CONTROLLER,
   APPLICATION_STATE_PROVIDER,
   STATE_CONFIG_PROVIDER,
@@ -58,7 +57,7 @@ module(PROJECTS_STATES_CONFIG, [
                   email: null,
                   config: null,
                   notFound: true,
-                };
+                } as IProject;
               },
             );
           },
@@ -88,9 +87,8 @@ module(PROJECTS_STATES_CONFIG, [
       url: '/projects',
       views: {
         'main@': {
-          templateUrl: require('../projects/projects.html'),
-          controller: 'ProjectsCtrl',
-          controllerAs: 'ctrl',
+          component: Projects,
+          $type: 'react',
         },
       },
       data: {

package/src/serverGroup/details/ServerGroupDetails.tsx

@@ -97,7 +97,7 @@ export class ServerGroupDetails extends React.Component<IServerGroupDetailsProps
             <div className="header-text horizontal middle">
               <CloudProviderLogo provider={serverGroup.type} height="36px" width="36px" />
               <h3 className="horizontal middle space-between flex-1">
-                {serverGroup.name}
+                {serverGroup.displayName ? serverGroup.displayName : serverGroup.name}
                 {showEntityTags && (
                   <EntityNotifications
                     entity={serverGroup}

package/src/serverGroupManager/ServerGroupManager.tsx

@@ -25,6 +25,7 @@ export class ServerGroupManager extends React.Component<IServerGroupManagerProps
       region: serverGroups[0].region,
       provider: serverGroups[0].cloudProvider,
       serverGroupManager: manager,
+      name: manager,
     };
     return ReactInjector.$state.includes('**.serverGroupManager', params);
   };
@@ -42,6 +43,7 @@ export class ServerGroupManager extends React.Component<IServerGroupManagerProps
       region: serverGroups[0].region,
       provider: serverGroups[0].cloudProvider,
       serverGroupManager: manager,
+      name: manager,
     });
   };
 

package/src/serverGroupManager/ServerGroupManagerTag.tsx

@@ -59,7 +59,7 @@ export class ServerGroupManagerTag extends React.Component<IServerGroupManagerTa
       accountId: serverGroupManager.account,
       region: serverGroupManager.region,
       provider: serverGroupManager.cloudProvider,
-      serverGroupManager: serverGroupManager.name,
+      name: serverGroupManager.name,
     };
   }
 }

package/src/serverGroupManager/index.ts

@@ -2,3 +2,4 @@ export * from './serverGroupManager.dataSource';
 export * from './serverGroupManager.states';
 export * from './ServerGroupManagerReader';
 export * from './ServerGroupManagerTag';
+export * from './ServerGroupManagerDetails';

package/src/serverGroupManager/serverGroupManager.states.ts

@@ -9,7 +9,7 @@ export interface IServerGroupManagerStateParams {
   provider: string;
   accountId: string;
   region: string;
-  serverGroupManager: string;
+  name: string;
 }
 
 export const SERVER_GROUP_MANAGER_STATES = 'spinnaker.core.serverGroupManager.states';
@@ -18,7 +18,7 @@ module(SERVER_GROUP_MANAGER_STATES, [APPLICATION_STATE_PROVIDER]).config([
   (applicationStateProvider: ApplicationStateProvider) => {
     const serverGroupManagerDetails: INestedState = {
       name: 'serverGroupManager',
-      url: '/serverGroupManagerDetails/:provider/:accountId/:region/:serverGroupManager',
+      url: '/serverGroupManagerDetails/:provider/:accountId/:region/:name',
       views: {
         'detail@../insight': {
           component: ServerGroupManagerDetails,
@@ -32,7 +32,7 @@ module(SERVER_GROUP_MANAGER_STATES, [APPLICATION_STATE_PROVIDER]).config([
       data: {
         pageTitleDetails: {
           title: 'Server Group Manager Details',
-          nameParam: 'serverGroupManager',
+          nameParam: 'name',
           accountParam: 'accountId',
           regionParam: 'region',
         },

package/src/utils/feature/Feature.tsx

@@ -0,0 +1,98 @@
+import * as React from 'react';
+
+import type { FeatureFlags } from './FeatureContext';
+import { useFeature } from './useFeature.hook';
+
+interface FeatureProps {
+  feature: keyof FeatureFlags;
+  children?: React.ReactNode;
+  render?: React.ReactNode;
+}
+
+/**
+ * Renders content conditionally based on the specified feature flag.
+ *
+ * @param {Object} props - The properties for the Feature component.
+ * @param {keyof FeatureFlags} props.feature - The name of the feature flag to check.
+ * @param {React.ReactNode} [props.children] - The content to render if the feature is enabled.
+ * @param {React.ReactNode} [props.render=children] - Optional custom render content; defaults to `children`.
+ *
+ * @returns {JSX.Element | null} - The rendered content if the feature is enabled; otherwise, `null`.
+ *
+ * @example
+ * // Example usage with children
+ * <Feature feature="slack">
+ *   <SlackComponent />
+ * </Feature>
+ *
+ * @example
+ * // Example usage with a custom render prop
+ * <Feature
+ *   feature="entityTags"
+ *   render={<EntityTagsComponent />}
+ * />
+ */
+export function Feature({ feature, children, render = children }: FeatureProps): JSX.Element | null {
+  const hasFeature = useFeature(feature);
+
+  // If the feature is disabled, render nothing.
+  if (!hasFeature) {
+    return null;
+  }
+
+  // Otherwise, render the node content.
+  return <React.Fragment>{render}</React.Fragment>;
+}
+
+/**
+ * An alias of the `<Feature />` component.
+ * Renders the provided content if the specified feature is enabled.
+ *
+ * @example
+ * <IfFeatureEnabled feature="slack">
+ *   <SlackComponent />
+ * </IfFeatureEnabled>
+ */
+export function IfFeatureEnabled({ feature, children, render = children }: FeatureProps): JSX.Element | null {
+  return <Feature feature={feature} render={render} />;
+}
+
+/**
+ * Higher-order function to wrap a component with a feature flag check.
+ * Ensures that the component only renders if the specified feature is enabled.
+ *
+ * @template Props
+ * @param {keyof FeatureFlags} feature - The name of the feature flag to check.
+ * @returns {(Component: React.ComponentType<Props>) => React.ComponentType<Props>} -
+ * A higher-order component (HOC) that conditionally renders the wrapped component.
+ *
+ * @example
+ * // Example usage
+ * const EnhancedComponent = withFeature('newFeature')(MyComponent);
+ *
+ * <EnhancedComponent someProp="value" />;
+ */
+export function withFeature<Props extends object>(
+  feature: keyof FeatureFlags,
+): (Component: React.ComponentType<Props>) => React.ComponentType<Props> {
+  return function wrapWithFeature(Component: React.ComponentType<Props>) {
+    /**
+     * Wraps the provided component with the <Feature> component,
+     * checking the specified feature flag before rendering.
+     *
+     * @param {Props} props - Props passed to the wrapped component.
+     * @returns {JSX.Element} - The wrapped component if the feature is enabled, or nothing if it is disabled.
+     */
+    function WithFeature(props: Props): JSX.Element {
+      return (
+        <Feature feature={feature}>
+          <Component {...props} />
+        </Feature>
+      );
+    }
+
+    WithFeature.displayName = `WithFeature(${Component.displayName || Component.name})`;
+
+    return WithFeature;
+  };
+}

package/src/utils/feature/FeatureContext.tsx

@@ -0,0 +1,49 @@
+import * as React from 'react';
+
+import type { IFeatures } from '../../config';
+import { SETTINGS } from '../../config';
+import { useFeatures } from './useFeature.hook';
+
+/**
+ * Type alias for feature flags, extending from IFeatures interface.
+ */
+export type FeatureFlags = IFeatures;
+
+/**
+ * Creates a React Context for feature flags.
+ * Defaults to `SETTINGS.feature` if no provider is found in the component tree.
+ */
+export const FeatureFlagsContext = React.createContext<FeatureFlags>(SETTINGS.feature);
+
+/**
+ * Merges two FeatureFlags objects. Flags in `b` will override flags in `a`.
+ *
+ * @param {FeatureFlags} a - The base feature flags.
+ * @param {FeatureFlags} b - The overriding feature flags.
+ * @returns {FeatureFlags} - A new object containing merged flags from `a` and `b`.
+ */
+function mergeFeatures(a: FeatureFlags, b: FeatureFlags): FeatureFlags {
+  return { ...a, ...b };
+}
+
+/**
+ * A context provider component that merges the global feature flags
+ * from `SETTINGS.feature` with any feature flags passed in via props.
+ *
+ * @param {Object} props
+ * @param {FeatureFlags} [props.features] - Feature flags to merge with the global flags.
+ * @param {React.ReactNode} props.children - Components that will consume the merged flags.
+ * @returns {JSX.Element} - The provider that holds merged feature flags in context.
+ */
+export function FeaturesProvider({
+  features = {},
+  children,
+}: {
+  features?: FeatureFlags;
+  children: React.ReactNode;
+}): JSX.Element {
+  const currentFeatures = useFeatures();
+  // Merge global settings with any flags provided to the provider
+  const mergedFeatures = React.useMemo(() => mergeFeatures(currentFeatures, features), [features]);
+  return <FeatureFlagsContext.Provider value={mergedFeatures}>{children}</FeatureFlagsContext.Provider>;
+}

package/src/utils/feature/index.ts

@@ -0,0 +1,3 @@
+export * from './Feature';
+export * from './FeatureContext';
+export * from './useFeature.hook';

package/src/utils/feature/useFeature.hook.tsx

@@ -0,0 +1,25 @@
+import React from 'react';
+
+import type { FeatureFlags } from './FeatureContext';
+import { FeatureFlagsContext } from './FeatureContext';
+
+/**
+ * A hook to access the current set of feature flags from the context.
+ * If no provider is found, it will default to `SETTINGS.feature`.
+ *
+ * @returns {FeatureFlags} - The feature flags currently in the context.
+ */
+export function useFeatures(): FeatureFlags {
+  return React.useContext(FeatureFlagsContext);
+}
+
+/**
+ * A hook to determine if a particular feature is enabled.
+ *
+ * @param {keyof FeatureFlags} feature - The name of the feature flag to check.
+ * @returns {boolean} - True if the feature is enabled; otherwise false.
+ */
+export function useFeature(feature: keyof FeatureFlags): boolean {
+  const features = useFeatures();
+  return features[feature];
+}

package/src/utils/index.ts

@@ -13,6 +13,7 @@ export * from './json/traverseObject';
 export * from './noop';
 export * from './q';
 export * from './renderIfFeature.component';
+export * from './feature';
 export * from './scrollTo/scrollTo.service';
 export * from './timeFormatters';
 export * from './unicodeBase64';
@@ -20,3 +21,4 @@ export * from './uuid.service';
 export * from './workerPool';
 export * from './json/filterObjectValues';
 export * from './Logger';
+export * from './parseNum';

package/src/utils/parseNum.ts

@@ -0,0 +1,2 @@
+export const parseNum = (numOrStr: number | string): number =>
+  typeof numOrStr === 'string' ? parseInt(numOrStr) : numOrStr;