@spinnaker/core 0.0.0-2025.1-0

package/src/presentation/hooks/useIsMountedRef.hook.spec.tsx

@@ -0,0 +1,62 @@
+import { mount } from 'enzyme';
+import React from 'react';
+
+import { useIsMountedRef } from '..';
+
+describe('useIsMountedRef hook', () => {
+  let useIsMountedRefSpy: jasmine.Spy;
+  let TestComponent: React.FunctionComponent;
+  let ref: React.RefObject<boolean>;
+  let isMountedInRender: boolean;
+
+  beforeEach(() => {
+    useIsMountedRefSpy = jasmine.createSpy('useIsMountedRef', useIsMountedRef).and.callThrough();
+
+    TestComponent = function () {
+      ref = useIsMountedRefSpy();
+      isMountedInRender = ref.current;
+      return null;
+    };
+  });
+
+  it('ref.current is false inside the initial render', () => {
+    mount(<TestComponent />);
+    expect(useIsMountedRefSpy).toHaveBeenCalledTimes(1);
+    expect(isMountedInRender).toBe(false);
+  });
+
+  it('ref.current is true after the initial render', () => {
+    mount(<TestComponent />);
+    expect(useIsMountedRefSpy).toHaveBeenCalledTimes(1);
+    expect(ref.current).toBe(true);
+  });
+
+  it('ref.current is true during and after the next render', () => {
+    const component = mount(<TestComponent />);
+    component.setProps({});
+    expect(useIsMountedRefSpy).toHaveBeenCalledTimes(2);
+    expect(isMountedInRender).toBe(true);
+    expect(ref.current).toBe(true);
+  });
+
+  it('ref.current remains true on subsequent renders', () => {
+    const component = mount(<TestComponent />);
+    component.setProps({});
+    component.setProps({});
+    component.setProps({});
+    expect(useIsMountedRefSpy).toHaveBeenCalledTimes(4);
+    expect(isMountedInRender).toBe(true);
+    expect(ref.current).toBe(true);
+  });
+
+  it('ref.current is false after the component unmounts', (done) => {
+    const component = mount(<TestComponent />);
+    expect(ref.current).toBe(true);
+
+    component.unmount();
+    setTimeout(() => {
+      expect(ref.current).toBe(false);
+      done();
+    });
+  });
+});

package/src/presentation/hooks/useIsMountedRef.hook.ts

@@ -0,0 +1,14 @@
+import { useEffect, useRef } from 'react';
+
+export function useIsMountedRef() {
+  const isMounted = useRef(false);
+
+  useEffect(() => {
+    isMounted.current = true;
+    return () => {
+      isMounted.current = false;
+    };
+  }, []);
+
+  return isMounted;
+}

package/src/presentation/hooks/useLatestCallback.hook.spec.tsx

@@ -0,0 +1,65 @@
+import { mount } from 'enzyme';
+import React from 'react';
+
+import { useLatestCallback } from './useLatestCallback.hook';
+
+const TestComponent = ({
+  callback,
+  onCallbackChange,
+}: {
+  callback: (...args: any) => any;
+  onCallbackChange: (callback: Function) => any;
+}) => {
+  const memoizedCallback = useLatestCallback(callback);
+  onCallbackChange(memoizedCallback);
+  return null as JSX.Element;
+};
+
+describe('useLatestCallback', () => {
+  it('should give back a stable function reference when the callback argument changes', () => {
+    const callbacksFromHook: any[] = [];
+    const onCallbackChange = (callback: any) => callbacksFromHook.push(callback);
+
+    const component = mount(<TestComponent callback={() => 'first'} onCallbackChange={onCallbackChange} />);
+
+    component.setProps({ callback: () => 'second' });
+
+    expect(callbacksFromHook.length).toBe(2);
+    expect(callbacksFromHook[0]).toBe(callbacksFromHook[1]);
+
+    component.setProps({ callback: () => 'third' });
+
+    expect(callbacksFromHook.length).toBe(3);
+    expect(callbacksFromHook[1]).toBe(callbacksFromHook[2]);
+  });
+
+  it('should always call the latest callback argument', () => {
+    let callbackFromHook: any;
+    const onCallbackChange = (callback: any) => (callbackFromHook = callback);
+
+    const initialCallback = jasmine.createSpy('initialCallback', () => 'initial');
+
+    const component = mount(<TestComponent callback={initialCallback} onCallbackChange={onCallbackChange} />);
+
+    callbackFromHook();
+    expect(initialCallback).toHaveBeenCalledTimes(1);
+
+    const updatedCallback = jasmine.createSpy('updatedCallback', () => 'updated');
+
+    component.setProps({ callback: updatedCallback });
+
+    callbackFromHook();
+    expect(initialCallback).toHaveBeenCalledTimes(1);
+    expect(updatedCallback).toHaveBeenCalledTimes(1);
+  });
+
+  it('should pass through the arguments/return value of the original callback', () => {
+    let callbackFromHook: any;
+    const onCallbackChange = (callback: any) => (callbackFromHook = callback);
+
+    mount(<TestComponent callback={(value) => `Hello ${value}`} onCallbackChange={onCallbackChange} />);
+
+    const returnValue = callbackFromHook('World');
+    expect(returnValue).toBe('Hello World');
+  });
+});

package/src/presentation/hooks/useLatestCallback.hook.ts

@@ -0,0 +1,17 @@
+import React from 'react';
+
+const { useRef, useCallback } = React;
+
+/**
+ * Returns a stable function reference that delegates to the latest version
+ * of the unstable function argument. Allows the latest version of the unstable
+ * function to access the latest version of its closure.
+ */
+export const useLatestCallback = <T extends (...args: any) => any>(callback: T) => {
+  const callbackRef = useRef(callback);
+  callbackRef.current = callback;
+
+  return useCallback((...args: Parameters<T>) => {
+    return callbackRef.current && (callbackRef.current.apply(null, args) as ReturnType<T>);
+  }, []);
+};

package/src/presentation/hooks/useLatestPromise.hook.spec.tsx

@@ -0,0 +1,160 @@
+import { mount } from 'enzyme';
+import React from 'react';
+
+import type { IUseLatestPromiseResult } from './useLatestPromise.hook';
+import { useLatestPromise } from './useLatestPromise.hook';
+
+describe('useLatestPromise hook', () => {
+  // Remove the the refresh function for .isEqual assertions
+  function promiseState(call: IUseLatestPromiseResult<any>) {
+    const { refresh, ...state } = call;
+    return state;
+  }
+
+  function Component(props: any) {
+    const { promiseFactory, deps, onChange } = props;
+    const useLatestPromiseResult: IUseLatestPromiseResult<any> = useLatestPromise(promiseFactory, deps);
+    const { status, result, error, requestId } = useLatestPromiseResult;
+
+    React.useEffect(() => onChange(useLatestPromiseResult), [status, result, error, requestId]);
+    return <></>;
+  }
+
+  function defer() {
+    let resolve: Function, reject: Function;
+    const promise = new Promise((_resolve, _reject) => {
+      resolve = _resolve;
+      reject = _reject;
+    });
+    return { promise, resolve, reject };
+  }
+
+  it('has status NONE if no promise has been returned', () => {
+    const spy = jasmine.createSpy('onChange');
+    mount(<Component promiseFactory={() => null as any} deps={[]} onChange={spy} />);
+    expect(spy).toHaveBeenCalledTimes(1);
+
+    const result: IUseLatestPromiseResult<any> = spy.calls.mostRecent().args[0];
+    expect(promiseState(result)).toEqual({ status: 'NONE', result: undefined, error: undefined, requestId: 0 });
+  });
+
+  it('has status PENDING if a promise has been returned but has not yet resolved', () => {
+    const spy = jasmine.createSpy('onChange');
+    const deferred = defer();
+    mount(<Component promiseFactory={() => deferred.promise} deps={[]} onChange={spy} />);
+    expect(spy).toHaveBeenCalledTimes(2);
+
+    const result: IUseLatestPromiseResult<any> = spy.calls.mostRecent().args[0];
+    expect(promiseState(result)).toEqual({ status: 'PENDING', result: undefined, error: undefined, requestId: 0 });
+  });
+
+  it('has status RESOLVED if a promise resolved', async () => {
+    const spy = jasmine.createSpy('onChange');
+    const deferred = defer();
+    const component = mount(<Component promiseFactory={() => deferred.promise} deps={[]} onChange={spy} />);
+    expect(spy).toHaveBeenCalledTimes(2);
+
+    deferred.resolve('payload');
+    await deferred.promise;
+    component.setProps({});
+
+    expect(spy).toHaveBeenCalledTimes(3);
+    const result: IUseLatestPromiseResult<any> = spy.calls.mostRecent().args[0];
+    expect(promiseState(result)).toEqual({ status: 'RESOLVED', result: 'payload', error: undefined, requestId: 0 });
+  });
+
+  it('has status REJECTED if a promise rejected', async () => {
+    const spy = jasmine.createSpy('onChange');
+    const deferred = defer();
+    const component = mount(<Component promiseFactory={() => deferred.promise} deps={[]} onChange={spy} />);
+    expect(spy).toHaveBeenCalledTimes(2);
+
+    deferred.reject('error');
+    let caught = false;
+    try {
+      await deferred.promise;
+    } catch (error) {
+      caught = true;
+    }
+    expect(caught).toBe(true);
+    component.setProps({});
+
+    expect(spy).toHaveBeenCalledTimes(3);
+    const result: IUseLatestPromiseResult<any> = spy.calls.mostRecent().args[0];
+    expect(promiseState(result)).toEqual({ status: 'REJECTED', result: undefined, error: 'error', requestId: 0 });
+  });
+
+  it('only handles the latest promise when multiple promises are pending', async () => {
+    const spy = jasmine.createSpy('onChange');
+    const deferred1 = defer();
+    const component = mount(<Component promiseFactory={() => deferred1.promise} deps={[1]} onChange={spy} />);
+    expect(spy).toHaveBeenCalledTimes(2);
+
+    const deferred2 = defer();
+    component.setProps({ promiseFactory: () => deferred2.promise, deps: [2] });
+    component.setProps({});
+    expect(spy).toHaveBeenCalledTimes(3);
+    expect(spy.calls.mostRecent().args[0].status).toEqual('PENDING');
+
+    deferred1.resolve('payload1');
+    await deferred1.promise;
+    component.setProps({});
+
+    expect(spy).toHaveBeenCalledTimes(3);
+    expect(spy.calls.mostRecent().args[0].status).toEqual('PENDING');
+
+    deferred2.resolve('payload2');
+    await deferred2.promise;
+    component.setProps({});
+
+    expect(spy).toHaveBeenCalledTimes(4);
+    const result: IUseLatestPromiseResult<any> = spy.calls.mostRecent().args[0];
+    expect(promiseState(result)).toEqual({ status: 'RESOLVED', result: 'payload2', error: undefined, requestId: 1 });
+  });
+
+  it('gets a new promise if refresh() is called', async () => {
+    const spy = jasmine.createSpy('onChange');
+    const deferred = defer();
+    const promiseFactorySpy = jasmine.createSpy('promiseFactory').and.callFake(() => deferred.promise);
+    const component = mount(<Component promiseFactory={promiseFactorySpy} deps={[]} onChange={spy} />);
+    expect(promiseFactorySpy).toHaveBeenCalledTimes(1);
+
+    // initial promise is resolved.
+    deferred.resolve('payload');
+    await deferred.promise;
+    component.setProps({});
+
+    spy.calls.mostRecent().args[0].refresh();
+    component.setProps({});
+    expect(promiseFactorySpy).toHaveBeenCalledTimes(2);
+  });
+
+  it('ignores old pending results if a newer promise is being processed', async () => {
+    const spy = jasmine.createSpy('onChange');
+    const deferred1 = defer();
+    const deferred2 = defer();
+    const component = mount(<Component promiseFactory={() => deferred1.promise} deps={[1]} onChange={spy} />);
+
+    component.setProps({ promiseFactory: () => deferred2.promise, deps: [2] });
+
+    // The first promise is resolved.
+    deferred1.resolve('payload1');
+    await deferred1.promise;
+    component.setProps({});
+
+    // The second promise is resolved.
+    deferred2.resolve('payload2');
+    await deferred2.promise;
+    component.setProps({});
+
+    expect(spy).toHaveBeenCalledTimes(4);
+    const allCalls = spy.calls.allArgs().map((args) => promiseState(args[0]));
+    expect(allCalls[0]).toEqual({ status: 'NONE', result: undefined, error: undefined, requestId: 0 });
+    // initial request
+    expect(allCalls[1]).toEqual({ status: 'PENDING', result: undefined, error: undefined, requestId: 0 });
+    // second request
+    expect(allCalls[2]).toEqual({ status: 'PENDING', result: undefined, error: undefined, requestId: 1 });
+    // resolved second request
+    expect(allCalls[3]).toEqual({ status: 'RESOLVED', result: 'payload2', error: undefined, requestId: 1 });
+  });
+});

package/src/presentation/hooks/useLatestPromise.hook.ts

@@ -0,0 +1,94 @@
+import type { DependencyList } from 'react';
+import { useEffect, useRef, useState } from 'react';
+import { useIsMountedRef } from './useIsMountedRef.hook';
+
+export type IRequestStatus = 'NONE' | 'PENDING' | 'REJECTED' | 'RESOLVED';
+
+export interface IUseLatestPromiseResult<T> {
+  // The value of the resolved promise returned from the callback
+  result: T;
+  // The status of the latest promise returned from the callback
+  status: IRequestStatus;
+  // The value of the rejected promise
+  error: any;
+  // A function that causes the callback to be invoked again
+  refresh: () => void;
+  // The current request ID -- could be used to count requests made, for example
+  requestId: number;
+}
+
+type IPromiseState<T> = Pick<IUseLatestPromiseResult<T>, 'result' | 'status' | 'error' | 'requestId'>;
+const initialPromiseState: IPromiseState<any> = {
+  error: undefined,
+  requestId: 0,
+  result: undefined,
+  status: 'NONE',
+};
+
+/**
+ * A react hook which invokes a callback that returns a promise.
+ * If multiple requests are made concurrently, only returns data from the latest request.
+ *
+ * This can be useful when fetching data based on a users keyboard input, for example.
+ * This behavior is similar to RxJS switchMap.
+ *
+ * example:
+ * const fetch = useLatestPromise(() => fetch(url + '?foo=" + foo).then(x=>x.json()), [foo]);
+ * return (fetch.status === 'RESOLVED' ? <pre>{JSON.stringify(fetch.result, null, 2)}</pre> :
+ *         fetch.status === 'REJECTED' ? <span>Error: {fetch.error}</span> :
+ *         fetch.status === 'PENDING' ? <span>Loading...</span> : null);
+ *
+ * @param callback a callback that returns a PromiseLike
+ * @param deps array of dependencies, which (when changed) cause the callback to be invoked again
+ * @returns an object with the result and current status of the promise
+ */
+export function useLatestPromise<T>(callback: () => PromiseLike<T>, deps: DependencyList): IUseLatestPromiseResult<T> {
+  const isMountedRef = useIsMountedRef();
+  // Capture the isMountedRef.current value before effects run
+  const isInitialRender = !isMountedRef.current;
+  const requestInFlight = useRef<PromiseLike<T>>();
+  // A counter that is used to trigger the promise handling useEffect
+  const [requestIdTrigger, setRequestIdTrigger] = useState(0);
+  const [promiseState, setPromiseState] = useState<IPromiseState<T>>(initialPromiseState);
+  const { result, error, status, requestId } = promiseState;
+
+  // Starts a new request (runs the callback again)
+  const refresh = () => setRequestIdTrigger((id) => id + 1);
+
+  // refresh whenever any dependency in the dependency list changes
+  useEffect(() => {
+    !isInitialRender && refresh();
+  }, deps);
+
+  // Invokes the callback and manages its lifecycle.
+  // This is triggered when the requestId changes
+  useEffect(() => {
+    const promise = callback();
+    const isCurrent = () => isMountedRef.current && promise === requestInFlight.current;
+
+    // If no promise is returned from the callback, noop this effect.
+    if (!promise) {
+      return;
+    }
+
+    // Don't clear out previous error/result when a new request is pending
+    setPromiseState({ status: 'PENDING', error, result, requestId: requestIdTrigger });
+    requestInFlight.current = promise;
+
+    const resolve = (newResult: T) => {
+      if (isCurrent()) {
+        setPromiseState({ status: 'RESOLVED', result: newResult, error: undefined, requestId: requestIdTrigger });
+      }
+    };
+
+    const reject = (rejection: any) => {
+      if (isCurrent()) {
+        setPromiseState({ status: 'REJECTED', result: undefined, error: rejection, requestId: requestIdTrigger });
+      }
+    };
+
+    promise.then(resolve, reject);
+  }, [requestIdTrigger]);
+
+  return { result, status, error, refresh, requestId };
+}

package/src/presentation/hooks/useMountStatusRef.hook.spec.tsx

@@ -0,0 +1,36 @@
+import { mount } from 'enzyme';
+import type { RefObject } from 'react';
+import React from 'react';
+
+import { useMountStatusRef } from './useMountStatusRef.hook';
+
+describe('useMountStatusRef', () => {
+  type TestCallback = (statusDuringRender: string, status: RefObject<string>) => void;
+  const TestComponent = ({ callback }: { callback: TestCallback }) => {
+    const mountStatusRef = useMountStatusRef();
+    callback(mountStatusRef.current, mountStatusRef);
+    return <i />;
+  };
+
+  it('current should follow the mount status of the component', async () => {
+    let mountStatusDuringRender: string;
+    let mountStatus: RefObject<string>;
+    const mounted = mount(
+      <TestComponent
+        callback={(statusDuringRender, statusRef) => {
+          mountStatusDuringRender = statusDuringRender;
+          mountStatus = statusRef;
+        }}
+      />,
+    );
+
+    expect(mountStatusDuringRender).toBe('FIRST_RENDER');
+    expect(mountStatus.current).toBe('MOUNTED');
+    mounted.setProps({});
+    expect(mountStatusDuringRender).toBe('MOUNTED');
+    expect(mountStatus.current).toBe('MOUNTED');
+    mounted.unmount();
+    expect(mountStatusDuringRender).toBe('MOUNTED');
+    expect(mountStatus.current).toBe('UNMOUNTED');
+  });
+});

package/src/presentation/hooks/useMountStatusRef.hook.ts

@@ -0,0 +1,12 @@
+import { useEffect, useRef } from 'react';
+
+export function useMountStatusRef() {
+  const mountStatusRef = useRef<'FIRST_RENDER' | 'MOUNTED' | 'UNMOUNTED'>('FIRST_RENDER');
+  useEffect(() => {
+    mountStatusRef.current = 'MOUNTED';
+    return () => {
+      mountStatusRef.current = 'UNMOUNTED';
+    };
+  });
+  return mountStatusRef;
+}

package/src/presentation/hooks/useObservable.hook.ts

@@ -0,0 +1,21 @@
+import { useEffect } from 'react';
+import type { Observable } from 'rxjs';
+
+/**
+ * A react hook that subscribes to an rxjs observable on mount and calls the provided callback when
+ * a new value is emitted. Unsubscribes on unmount or when the observable parameter changes.
+ *
+ * @param observable the rxjs observable to subscribe to
+ * @param callback the function to call when the observable emits a value.
+ * Passed the new value as its only argument.
+ * @returns void
+ */
+export const useObservable = <T>(observable: Observable<T>, callback: (val: T) => void) => {
+  useEffect(() => {
+    if (!observable) {
+      return undefined;
+    }
+    const subscription = observable.subscribe(callback);
+    return () => subscription.unsubscribe();
+  }, [observable]);
+};

package/src/presentation/hooks/useObservableValue.hook.ts

@@ -0,0 +1,19 @@
+import { useState } from 'react';
+import type { Observable } from 'rxjs';
+
+import { useObservable } from './useObservable.hook';
+
+/**
+ * A react hook that returns the current value of an rxjs observable
+ * and triggers a re-render when a new value is emitted.
+ *
+ * @param observable the rxjs observable to subscribe to
+ * @param defaultValue the (optional) value to return before the observable
+ * has emitted a value (for example, when the component is first mounting)
+ * @returns the most recent value of the observable
+ */
+export const useObservableValue = <T>(observable: Observable<T>, defaultValue?: T) => {
+  const [value, setValue] = useState<T>(defaultValue);
+  useObservable(observable, setValue);
+  return value;
+};

package/src/presentation/hooks/usePollingData.hook.spec.tsx

@@ -0,0 +1,125 @@
+import { mount } from 'enzyme';
+import React, { useEffect } from 'react';
+
+import type { IUseLatestPromiseResult } from './useLatestPromise.hook';
+import { usePollingData } from './usePollingData.hook';
+
+describe('usePollingData hook', () => {
+  beforeEach(() => jasmine.clock().install());
+  afterEach(() => jasmine.clock().uninstall());
+
+  // Remove the the refresh function for .isEqual assertions
+  function promiseState(call: IUseLatestPromiseResult<any>) {
+    const { refresh, ...state } = call;
+    return state;
+  }
+
+  function Component(props: any) {
+    const { promiseFactory, defaultValue, pollingInterval, deps, onChange } = props;
+    const useDataResult: IUseLatestPromiseResult<any> = usePollingData(
+      promiseFactory,
+      defaultValue,
+      pollingInterval,
+      deps,
+    );
+    const { status, result, error, requestId } = useDataResult;
+
+    useEffect(() => onChange(useDataResult), [status, result, error, requestId]);
+
+    return <></>;
+  }
+
+  function defer() {
+    let resolve: Function, reject: Function;
+    const promise = new Promise((_resolve, _reject) => {
+      resolve = _resolve;
+      reject = _reject;
+    });
+    return { promise, resolve, reject };
+  }
+
+  it('delegates to useData', () => {
+    const spy = jasmine.createSpy('onChange');
+    const deferred = defer();
+    const factory = () => deferred.promise;
+    mount(
+      <Component
+        promiseFactory={factory}
+        deps={['foo']}
+        defaultValue={'default'}
+        pollingInterval={1000}
+        onChange={spy}
+      />,
+    );
+
+    expect(spy).toHaveBeenCalledTimes(2);
+
+    expect(promiseState(spy.calls.argsFor(0)[0])).toEqual({
+      status: 'NONE',
+      result: 'default',
+      error: undefined,
+      requestId: 0,
+    });
+
+    expect(promiseState(spy.calls.argsFor(1)[0])).toEqual({
+      status: 'PENDING',
+      result: 'default',
+      error: undefined,
+      requestId: 0,
+    });
+  });
+
+  it('calls the factory on the specified polling interval', async () => {
+    const spy = jasmine.createSpy('onChange');
+    let deferred = defer();
+    const factory = jasmine.createSpy('factory').and.callFake(() => deferred.promise);
+    const component = mount(
+      <Component
+        promiseFactory={factory}
+        deps={['foo']}
+        defaultValue="default"
+        pollingInterval={1000}
+        onChange={spy}
+      />,
+    );
+
+    deferred.resolve('result');
+    await deferred.promise;
+    component.setProps({});
+    expect(factory).toHaveBeenCalledTimes(1);
+    expect(spy).toHaveBeenCalledTimes(3);
+    expect(promiseState(spy.calls.argsFor(2)[0])).toEqual({
+      status: 'RESOLVED',
+      result: 'result',
+      error: undefined,
+      requestId: 0,
+    });
+
+    // Reset to a new deferred promise to simulate calling
+    // a real factory function again
+    deferred = defer();
+
+    // Tick forward to slightly before the polling interval should kick in
+    jasmine.clock().tick(900);
+    component.setProps({});
+
+    // Confirm that ticking forward didn't trigger a refresh
+    expect(factory).toHaveBeenCalledTimes(1);
+    expect(spy).toHaveBeenCalledTimes(3);
+
+    // Clock is now at 1400ms, 400ms past the polling interval
+    jasmine.clock().tick(500);
+    component.setProps({});
+
+    // Confirm that the useData result was refreshed
+    expect(factory).toHaveBeenCalledTimes(2);
+    expect(spy).toHaveBeenCalledTimes(4);
+
+    expect(promiseState(spy.calls.argsFor(3)[0])).toEqual({
+      status: 'PENDING',
+      result: 'result',
+      error: undefined,
+      requestId: 1,
+    });
+  });
+});

package/src/presentation/hooks/usePollingData.hook.ts

@@ -0,0 +1,44 @@
+import { useEffect } from 'react';
+
+import { SchedulerFactory } from '../../scheduler';
+
+import { useData } from './useData.hook';
+import { useLatestCallback } from './useLatestCallback.hook';
+import type { IUseLatestPromiseResult } from './useLatestPromise.hook';
+
+/**
+ * A react hook which invokes a promise factory callback whenever any of its dependencies
+ * changes *and* on a specific polling schedule.
+ *
+ * Returns the default result until the first promise resolves.
+ *
+ * The promise factory is not called if any of the deps are null or undefined.
+ *
+ * This can be useful when fetching data based on a users keyboard input, for example.
+ * This behavior is similar to RxJS switchMap.
+ *
+ * @param callback the callback to be invoked whenever dependencies change and on a polling schedule
+ * @param defaultResult the default result returned before the first promise resolves
+ * @param pollingInterval the time interval (in milliseconds) for how often to invoke the callback
+ * @param deps array of dependencies, which (when changed) cause the callback to be invoked again
+ * @returns an object with the result and current status of the promise
+ */
+export function usePollingData<T>(
+  callback: () => PromiseLike<T>,
+  defaultResult: T,
+  pollingInterval: number,
+  deps: any[],
+): IUseLatestPromiseResult<T> {
+  const result = useData<T>(callback, defaultResult, deps);
+  const refreshCallback = useLatestCallback(result.refresh);
+
+  useEffect(() => {
+    const { subscribe, unsubscribe } = SchedulerFactory.createScheduler(pollingInterval);
+
+    subscribe(refreshCallback);
+
+    return unsubscribe;
+  }, deps);
+
+  return result;
+}