@algolia/autocomplete-core 1.5.1 → 1.5.2

package/dist/esm/createStore.js

@@ -4,6 +4,7 @@ function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { va
 
 function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
 
+import { createCancelablePromiseList } from './utils';
 export function createStore(reducer, props, onStoreStateChange) {
   var state = props.initialState;
   return {
@@ -23,6 +24,6 @@ export function createStore(reducer, props, onStoreStateChange) {
         prevState: prevState
       });
     },
-    shouldSkipPendingUpdate: false
+    pendingRequests: createCancelablePromiseList()
   };
 }

package/dist/esm/getPropGetters.js

@@ -41,12 +41,12 @@ export function getPropGetters(_ref) {
         // The `onTouchStart` event shouldn't trigger the `blur` handler when
         // it's not an interaction with Autocomplete. We detect it with the
         // following heuristics:
-        // - the panel is closed AND there are no running requests
+        // - the panel is closed AND there are no pending requests
         //   (no interaction with the autocomplete, no future state updates)
         // - OR the touched target is the input element (should open the panel)
-        var isNotAutocompleteInteraction = store.getState().isOpen === false && !onInput.isRunning();
+        var isAutocompleteInteraction = store.getState().isOpen || !store.pendingRequests.isEmpty();
 
-        if (isNotAutocompleteInteraction || event.target === inputElement) {
+        if (!isAutocompleteInteraction || event.target === inputElement) {
           return;
         }
 
@@ -55,13 +55,13 @@ export function getPropGetters(_ref) {
         });
 
         if (isTargetWithinAutocomplete === false) {
-          store.dispatch('blur', null); // If requests are still running when the user closes the panel, they
+          store.dispatch('blur', null); // If requests are still pending when the user closes the panel, they
           // could reopen the panel once they resolve.
           // We want to prevent any subsequent query from reopening the panel
           // because it would result in an unsolicited UI behavior.
 
-          if (!props.debug && onInput.isRunning()) {
-            store.shouldSkipPendingUpdate = true;
+          if (!props.debug) {
+            store.pendingRequests.cancelAll();
           }
         }
       },
@@ -188,13 +188,13 @@ export function getPropGetters(_ref) {
         // We do rely on the `blur` event on touch devices.
         // See explanation in `onTouchStart`.
         if (!isTouchDevice) {
-          store.dispatch('blur', null); // If requests are still running when the user closes the panel, they
+          store.dispatch('blur', null); // If requests are still pending when the user closes the panel, they
           // could reopen the panel once they resolve.
           // We want to prevent any subsequent query from reopening the panel
           // because it would result in an unsolicited UI behavior.
 
-          if (!props.debug && onInput.isRunning()) {
-            store.shouldSkipPendingUpdate = true;
+          if (!props.debug) {
+            store.pendingRequests.cancelAll();
           }
         }
       },

package/dist/esm/onInput.d.ts

@@ -1,4 +1,5 @@
 import { AutocompleteScopeApi, AutocompleteState, AutocompleteStore, BaseItem, InternalAutocompleteOptions } from './types';
+import { CancelablePromise } from './utils';
 interface OnInputParams<TItem extends BaseItem> extends AutocompleteScopeApi<TItem> {
     event: any;
     /**
@@ -13,8 +14,5 @@ interface OnInputParams<TItem extends BaseItem> extends AutocompleteScopeApi<TIt
     query: string;
     store: AutocompleteStore<TItem>;
 }
-export declare function onInput<TItem extends BaseItem>({ event, nextState, props, query, refresh, store, ...setters }: OnInputParams<TItem>): Promise<void>;
-export declare namespace onInput {
-    var isRunning: () => boolean;
-}
+export declare function onInput<TItem extends BaseItem>({ event, nextState, props, query, refresh, store, ...setters }: OnInputParams<TItem>): CancelablePromise<void>;
 export {};

package/dist/esm/onInput.js

@@ -12,7 +12,7 @@ function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) r
 
 import { reshape } from './reshape';
 import { preResolve, resolve, postResolve } from './resolve';
-import { createConcurrentSafePromise, getActiveItem } from './utils';
+import { cancelable, createConcurrentSafePromise, getActiveItem } from './utils';
 var lastStalledId = null;
 var runConcurrentSafePromise = createConcurrentSafePromise();
 export function onInput(_ref) {
@@ -54,9 +54,11 @@ export function onInput(_ref) {
     // updates performed in this code path.
     // We chain with a void promise to respect `onInput`'s expected return type.
 
-    return runConcurrentSafePromise(collections).then(function () {
+    var _request = cancelable(runConcurrentSafePromise(collections).then(function () {
       return Promise.resolve();
-    });
+    }));
+
+    return store.pendingRequests.add(_request);
   }
 
   setStatus('loading');
@@ -69,7 +71,7 @@ export function onInput(_ref) {
   // meaning we should only ever manipulate the state once this concurrent-safe
   // promise is resolved.
 
-  return runConcurrentSafePromise(props.getSources(_objectSpread({
+  var request = cancelable(runConcurrentSafePromise(props.getSources(_objectSpread({
     query: query,
     refresh: refresh,
     state: store.getState()
@@ -91,7 +93,7 @@ export function onInput(_ref) {
         state: store.getState()
       });
     });
-  })).then(function (collections) {
+  }))).then(function (collections) {
     var _nextState$isOpen2;
 
     // Parameters passed to `onInput` could be stale when the following code
@@ -99,15 +101,6 @@ export function onInput(_ref) {
     // If it becomes a problem we'll need to save the last passed parameters.
     // See: https://codesandbox.io/s/agitated-cookies-y290z
     setStatus('idle');
-
-    if (store.shouldSkipPendingUpdate) {
-      if (!runConcurrentSafePromise.isRunning()) {
-        store.shouldSkipPendingUpdate = false;
-      }
-
-      return;
-    }
-
     setCollections(collections);
     var isPanelOpen = props.shouldPanelOpen({
       state: store.getState()
@@ -131,9 +124,11 @@ export function onInput(_ref) {
       }, setters));
     }
   }).finally(function () {
+    setStatus('idle');
+
     if (lastStalledId) {
       props.environment.clearTimeout(lastStalledId);
     }
   });
-}
-onInput.isRunning = runConcurrentSafePromise.isRunning;
+  return store.pendingRequests.add(request);
+}

package/dist/esm/onKeyDown.js

@@ -88,12 +88,10 @@ export function onKeyDown(_ref) {
     event.preventDefault();
     store.dispatch(event.key, null); // Hitting the `Escape` key signals the end of a user interaction with the
     // autocomplete. At this point, we should ignore any requests that are still
-    // running and could reopen the panel once they resolve, because that would
+    // pending and could reopen the panel once they resolve, because that would
     // result in an unsolicited UI behavior.
 
-    if (onInput.isRunning()) {
-      store.shouldSkipPendingUpdate = true;
-    }
+    store.pendingRequests.cancelAll();
   } else if (event.key === 'Enter') {
     // No active item, so we let the browser handle the native `onSubmit` form
     // event.

package/dist/esm/types/AutocompleteStore.d.ts

@@ -1,10 +1,11 @@
+import { CancelablePromiseList } from '../utils';
 import { BaseItem } from './AutocompleteApi';
 import { InternalAutocompleteOptions } from './AutocompleteOptions';
 import { AutocompleteState } from './AutocompleteState';
 export interface AutocompleteStore<TItem extends BaseItem> {
     getState(): AutocompleteState<TItem>;
     dispatch(action: ActionType, payload: any): void;
-    shouldSkipPendingUpdate: boolean;
+    pendingRequests: CancelablePromiseList<void>;
 }
 export declare type Reducer = <TItem extends BaseItem>(state: AutocompleteState<TItem>, action: Action<TItem, any>) => AutocompleteState<TItem>;
 declare type Action<TItem extends BaseItem, TPayload> = {

package/dist/esm/utils/createCancelablePromise.d.ts

@@ -0,0 +1,15 @@
+declare type PromiseExecutor<TValue> = (resolve: (value: TValue | PromiseLike<TValue>) => void, reject: (reason?: any) => void) => void;
+export declare type CancelablePromise<TValue> = {
+    then<TResultFulfilled = TValue, TResultRejected = never>(onfulfilled?: ((value: TValue) => TResultFulfilled | PromiseLike<TResultFulfilled> | CancelablePromise<TResultFulfilled>) | undefined | null, onrejected?: ((reason: any) => TResultRejected | PromiseLike<TResultRejected> | CancelablePromise<TResultRejected>) | undefined | null): CancelablePromise<TResultFulfilled | TResultRejected>;
+    catch<TResult = never>(onrejected?: ((reason: any) => TResult | PromiseLike<TResult> | CancelablePromise<TResult>) | undefined | null): CancelablePromise<TValue | TResult>;
+    finally(onfinally?: (() => void) | undefined | null): CancelablePromise<TValue>;
+    cancel(): void;
+    isCanceled(): boolean;
+};
+export declare function createCancelablePromise<TValue>(executor: PromiseExecutor<TValue>): CancelablePromise<TValue>;
+export declare namespace createCancelablePromise {
+    var resolve: <TValue>(value?: TValue | PromiseLike<TValue> | CancelablePromise<TValue> | undefined) => CancelablePromise<TValue | CancelablePromise<TValue> | undefined>;
+    var reject: (reason?: any) => CancelablePromise<never>;
+}
+export declare function cancelable<TValue>(promise: Promise<TValue>): CancelablePromise<TValue>;
+export {};

package/dist/esm/utils/createCancelablePromise.js

@@ -0,0 +1,70 @@
+function createInternalCancelablePromise(promise, initialState) {
+  var state = initialState;
+  return {
+    then: function then(onfulfilled, onrejected) {
+      return createInternalCancelablePromise(promise.then(createCallback(onfulfilled, state, promise), createCallback(onrejected, state, promise)), state);
+    },
+    catch: function _catch(onrejected) {
+      return createInternalCancelablePromise(promise.catch(createCallback(onrejected, state, promise)), state);
+    },
+    finally: function _finally(onfinally) {
+      if (onfinally) {
+        state.onCancelList.push(onfinally);
+      }
+
+      return createInternalCancelablePromise(promise.finally(createCallback(onfinally && function () {
+        state.onCancelList = [];
+        return onfinally();
+      }, state, promise)), state);
+    },
+    cancel: function cancel() {
+      state.isCanceled = true;
+      var callbacks = state.onCancelList;
+      state.onCancelList = [];
+      callbacks.forEach(function (callback) {
+        callback();
+      });
+    },
+    isCanceled: function isCanceled() {
+      return state.isCanceled === true;
+    }
+  };
+}
+
+export function createCancelablePromise(executor) {
+  return createInternalCancelablePromise(new Promise(function (resolve, reject) {
+    return executor(resolve, reject);
+  }), {
+    isCanceled: false,
+    onCancelList: []
+  });
+}
+
+createCancelablePromise.resolve = function (value) {
+  return cancelable(Promise.resolve(value));
+};
+
+createCancelablePromise.reject = function (reason) {
+  return cancelable(Promise.reject(reason));
+};
+
+export function cancelable(promise) {
+  return createInternalCancelablePromise(promise, {
+    isCanceled: false,
+    onCancelList: []
+  });
+}
+
+function createCallback(onResult, state, fallback) {
+  if (!onResult) {
+    return fallback;
+  }
+
+  return function callback(arg) {
+    if (state.isCanceled) {
+      return arg;
+    }
+
+    return onResult(arg);
+  };
+}

package/dist/esm/utils/createCancelablePromiseList.d.ts

@@ -0,0 +1,7 @@
+import { CancelablePromise } from '.';
+export declare type CancelablePromiseList<TValue> = {
+    add(cancelablePromise: CancelablePromise<TValue>): CancelablePromise<TValue>;
+    cancelAll(): void;
+    isEmpty(): boolean;
+};
+export declare function createCancelablePromiseList<TValue>(): CancelablePromiseList<TValue>;

package/dist/esm/utils/createCancelablePromiseList.js

@@ -0,0 +1,21 @@
+export function createCancelablePromiseList() {
+  var list = [];
+  return {
+    add: function add(cancelablePromise) {
+      list.push(cancelablePromise);
+      return cancelablePromise.finally(function () {
+        list = list.filter(function (item) {
+          return item !== cancelablePromise;
+        });
+      });
+    },
+    cancelAll: function cancelAll() {
+      list.forEach(function (promise) {
+        return promise.cancel();
+      });
+    },
+    isEmpty: function isEmpty() {
+      return list.length === 0;
+    }
+  };
+}

package/dist/esm/utils/createConcurrentSafePromise.d.ts

@@ -5,7 +5,4 @@ import { MaybePromise } from '@algolia/autocomplete-shared';
  * This is useful to prevent older promises to resolve after a newer promise,
  * otherwise resulting in stale resolved values.
  */
-export declare function createConcurrentSafePromise(): {
-    <TValue>(promise: MaybePromise<TValue>): Promise<TValue>;
-    isRunning(): boolean;
-};
+export declare function createConcurrentSafePromise(): <TValue>(promise: MaybePromise<TValue>) => Promise<TValue>;

package/dist/esm/utils/createConcurrentSafePromise.js

@@ -8,11 +8,8 @@ export function createConcurrentSafePromise() {
   var basePromiseId = -1;
   var latestResolvedId = -1;
   var latestResolvedValue = undefined;
-  var runningPromisesCount = 0;
-
-  function runConcurrentSafePromise(promise) {
+  return function runConcurrentSafePromise(promise) {
     basePromiseId++;
-    runningPromisesCount++;
     var currentPromiseId = basePromiseId;
     return Promise.resolve(promise).then(function (x) {
       // The promise might take too long to resolve and get outdated. This would
@@ -35,14 +32,6 @@ export function createConcurrentSafePromise() {
       latestResolvedId = currentPromiseId;
       latestResolvedValue = x;
       return x;
-    }).finally(function () {
-      return runningPromisesCount--;
     });
-  }
-
-  runConcurrentSafePromise.isRunning = function () {
-    return runningPromisesCount > 0;
   };
-
-  return runConcurrentSafePromise;
 }

package/dist/esm/utils/index.d.ts

@@ -1,3 +1,5 @@
+export * from './createCancelablePromise';
+export * from './createCancelablePromiseList';
 export * from './createConcurrentSafePromise';
 export * from './getNextActiveItemId';
 export * from './getNormalizedSources';

package/dist/esm/utils/index.js

@@ -1,3 +1,5 @@
+export * from './createCancelablePromise';
+export * from './createCancelablePromiseList';
 export * from './createConcurrentSafePromise';
 export * from './getNextActiveItemId';
 export * from './getNormalizedSources';