@warp-drive/ember 0.0.0-beta.1 → 0.0.0-beta.11

package/dist/index.js

@@ -6,26 +6,7 @@ import { macroCondition, moduleExists, importSync, getGlobalConfig } from '@embr
 import { EnableHydration } from '@warp-drive/core-types/request';
 import { precompileTemplate } from '@ember/template-compilation';
 import { setComponentTemplate } from '@ember/component';
-var __defProp = Object.defineProperty;
-var __export = (target, all) => {
-  for (var name in all) __defProp(target, name, {
-    get: all[name],
-    enumerable: true
-  });
-};
-
-// src/runtime.ts
-var runtime_exports = {};
-__export(runtime_exports, {
-  c: () => decorateClass,
-  f: () => decorateFieldV1,
-  g: () => decorateFieldV2,
-  i: () => initializeDeferredDecorator,
-  m: () => decorateMethodV1,
-  n: () => decorateMethodV2,
-  p: () => decoratePOJO
-});
-var deferred = /* @__PURE__ */new WeakMap();
+const deferred = /* @__PURE__ */new WeakMap();
 function deferDecorator(proto, prop, desc) {
   let map = deferred.get(proto);
   if (!map) {
@@ -35,18 +16,16 @@ function deferDecorator(proto, prop, desc) {
   map.set(prop, desc);
 }
 function findDeferredDecorator(target, prop) {
+  var _a;
   let cursor = target.prototype;
   while (cursor) {
-    let desc = deferred.get(cursor)?.get(prop);
+    let desc = (_a = deferred.get(cursor)) == null ? void 0 : _a.get(prop);
     if (desc) {
       return desc;
     }
     cursor = cursor.prototype;
   }
 }
-function decorateFieldV1(target, prop, decorators, initializer) {
-  return decorateFieldV2(target.prototype, prop, decorators, initializer);
-}
 function decorateFieldV2(prototype, prop, decorators, initializer) {
   let desc = {
     configurable: true,
@@ -66,11 +45,6 @@ function decorateFieldV2(prototype, prop, decorators, initializer) {
     deferDecorator(prototype, prop, desc);
   }
 }
-function decorateMethodV1({
-  prototype
-}, prop, decorators) {
-  return decorateMethodV2(prototype, prop, decorators);
-}
 function decorateMethodV2(prototype, prop, decorators) {
   const origDesc = Object.getOwnPropertyDescriptor(prototype, prop);
   let desc = {
@@ -96,35 +70,6 @@ function initializeDeferredDecorator(target, prop) {
     });
   }
 }
-function decorateClass(target, decorators) {
-  return decorators.reduce((accum, decorator) => decorator(accum) || accum, target);
-}
-function decoratePOJO(pojo, decorated) {
-  for (let [type, prop, decorators] of decorated) {
-    if (type === "field") {
-      decoratePojoField(pojo, prop, decorators);
-    } else {
-      decorateMethodV2(pojo, prop, decorators);
-    }
-  }
-  return pojo;
-}
-function decoratePojoField(pojo, prop, decorators) {
-  let desc = {
-    configurable: true,
-    enumerable: true,
-    writable: true,
-    initializer: () => Object.getOwnPropertyDescriptor(pojo, prop)?.value
-  };
-  for (let decorator of decorators) {
-    desc = decorator(pojo, prop, desc) || desc;
-  }
-  if (desc.initializer) {
-    desc.value = desc.initializer.call(pojo);
-    delete desc.initializer;
-  }
-  Object.defineProperty(pojo, prop, desc);
-}
 const RequestCache = new WeakMap();
 function isAbortError(error) {
   return error instanceof DOMException && error.name === 'AbortError';
@@ -542,10 +487,10 @@ function getPromiseState(promise) {
   }
   return state;
 }
-const and = (x1, y1) => Boolean(x1 && y1);
+const and = (x, y) => Boolean(x && y);
 class Throw extends Component {
-  constructor(owner1, args1) {
-    super(owner1, args1);
+  constructor(owner, args) {
+    super(owner, args);
     // this error is opaque (user supplied) so we don't validate it
     // as an Error instance.
     // eslint-disable-next-line @typescript-eslint/no-throw-literal
@@ -577,33 +522,44 @@ class Await extends Component {
     }), this);
   }
 }
-function notNull(x1) {
+function notNull(x) {
   macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
     if (!test) {
       throw new Error('Expected a non-null value, but got null');
     }
-  })(x1 !== null) : {};
-  return x1;
+  })(x !== null) : {};
+  return x;
 }
-const not = x1 => !x1;
+const not = x => !x;
 // default to 30 seconds unavailable before we refresh
 const DEFAULT_DEADLINE = 30_000;
-let provide = service;
+const IdleBlockMissingError = new Error('No idle block provided for <Request> component, and no query or request was provided.');
+let consume = service;
 if (macroCondition(moduleExists('ember-provide-consume-context'))) {
   const {
-    consume
+    consume: contextConsume
   } = importSync('ember-provide-consume-context');
-  provide = consume;
+  consume = contextConsume;
 }
-function isNeverString(val1) {
-  return val1;
+function isNeverString(val) {
+  return val;
 }
+/**
+ * The `<Request>` component is a powerful tool for managing data fetching and
+ * state in your Ember application. It provides declarative reactive control-flow
+ * for managing requests and state in your application.
+ *
+ * @typedoc
+ */
 class Request extends Component {
   static {
-    decorateFieldV2(this.prototype, "_store", [provide('store')]);
+    decorateFieldV2(this.prototype, "_store", [consume('store')]);
   }
   #_store = (initializeDeferredDecorator(this, "_store"), void 0);
   /**
+  * The store instance to use for making requests. If contexts are available, this
+  * will be the `store` on the context, else it will be the store service.
+  *
   * @internal
   */
   static {
@@ -612,35 +568,286 @@ class Request extends Component {
     });
   }
   #isOnline = (initializeDeferredDecorator(this, "isOnline"), void 0);
+  /**
+  * Whether the browser reports that the network is online.
+  *
+  * @internal
+  */
   static {
     decorateFieldV2(this.prototype, "isHidden", [tracked], function () {
       return true;
     });
   }
   #isHidden = (initializeDeferredDecorator(this, "isHidden"), void 0);
+  /**
+  * Whether the browser reports that the tab is hidden.
+  *
+  * @internal
+  */
   static {
     decorateFieldV2(this.prototype, "isRefreshing", [tracked], function () {
       return false;
     });
   }
   #isRefreshing = (initializeDeferredDecorator(this, "isRefreshing"), void 0);
+  /**
+  * Whether the component is currently refreshing the request.
+  *
+  * @internal
+  */
   static {
     decorateFieldV2(this.prototype, "_localRequest", [tracked]);
   }
   #_localRequest = (initializeDeferredDecorator(this, "_localRequest"), void 0);
+  /**
+  * The most recent blocking request that was made, typically
+  * the result of a reload.
+  *
+  * This will never be the original request passed as an arg to
+  * the component.
+  *
+  * @internal
+  */
   static {
     decorateFieldV2(this.prototype, "_latestRequest", [tracked]);
   }
   #_latestRequest = (initializeDeferredDecorator(this, "_latestRequest"), void 0);
+  /**
+  * The most recent request that was made, typically due to either a
+  * reload or a refresh.
+  *
+  * This will never be the original request passed as an arg to
+  * the component.
+  *
+  * @internal
+  */
+  /**
+  * The time at which the network was reported as offline.
+  *
+  * @internal
+  */
   unavailableStart;
+  intervalStart;
+  nextInterval;
+  invalidated;
+  isUpdating;
+  /**
+  * The event listener for network status changes,
+  * cached to use the reference for removal.
+  *
+  * @internal
+  */
   onlineChanged;
+  /**
+  * The event listener for visibility status changes,
+  * cached to use the reference for removal.
+  *
+  * @internal
+  */
   backgroundChanged;
+  /**
+  * The last request passed as an arg to the component,
+  * cached for comparison.
+  *
+  * @internal
+  */
   _originalRequest;
+  /**
+  * The last query passed as an arg to the component,
+  * cached for comparison.
+  *
+  * @internal
+  */
   _originalQuery;
-  constructor(owner1, args1) {
-    super(owner1, args1);
+  _subscription;
+  _subscribedTo;
+  constructor(owner, args) {
+    super(owner, args);
+    this._subscribedTo = null;
+    this._subscription = null;
+    this.intervalStart = null;
+    this.invalidated = false;
+    this.nextInterval = null;
     this.installListeners();
+    void this.beginPolling();
+  }
+  async beginPolling() {
+    // await the initial request
+    try {
+      await this.request;
+    } catch {
+      // ignore errors here, we just want to wait for the request to finish
+    } finally {
+      if (!this.isDestroyed) {
+        void this.scheduleInterval();
+      }
+    }
+  }
+  get isIdle() {
+    const {
+      request,
+      query
+    } = this.args;
+    return Boolean(!request && !query);
+  }
+  static {
+    decorateMethodV2(this.prototype, "isIdle", [cached]);
+  }
+  get autorefreshTypes() {
+    const {
+      autorefresh
+    } = this.args;
+    let types;
+    if (autorefresh === true) {
+      types = ['online', 'invalid'];
+    } else if (typeof autorefresh === 'string') {
+      types = autorefresh.split(',');
+    } else {
+      types = [];
+    }
+    return new Set(types);
+  }
+  // we only run this function on component creation
+  // and when an update is triggered, so it does not
+  // react to changes in the autorefreshThreshold
+  // or autorefresh args.
+  //
+  // if we need to react to those changes, we can
+  // use a modifier or internal component or some
+  // such to trigger a re-run of this function.
+  static {
+    decorateMethodV2(this.prototype, "autorefreshTypes", [cached]);
+  }
+  async scheduleInterval() {
+    const {
+      autorefreshThreshold
+    } = this.args;
+    const hasValidThreshold = typeof autorefreshThreshold === 'number' && autorefreshThreshold > 0;
+    if (typeof window === 'undefined' ||
+    // dont schedule without a threshold
+    !hasValidThreshold ||
+    // dont schedule if we weren't told to
+    !this.autorefreshTypes.has('interval') ||
+    // dont schedule if we're already scheduled
+    this.intervalStart !== null) {
+      return;
+    }
+    // if we have a current request, wait for it to finish
+    // before scheduling the next one
+    if (this._latestRequest) {
+      try {
+        await this._latestRequest;
+      } catch {
+        // ignore errors here, we just want to wait for the request to finish
+      }
+      if (this.isDestroyed) {
+        return;
+      }
+    }
+    // setup the next interval
+    this.intervalStart = Date.now();
+    this.nextInterval = setTimeout(() => {
+      this.maybeUpdate();
+    }, autorefreshThreshold);
   }
+  clearInterval() {
+    if (this.nextInterval) {
+      clearTimeout(this.nextInterval);
+      this.intervalStart = null;
+    }
+  }
+  updateSubscriptions() {
+    if (this.isIdle) {
+      return;
+    }
+    const requestId = this._request.lid;
+    // if we're already subscribed to this request, we don't need to do anything
+    if (this._subscribedTo === requestId) {
+      return;
+    }
+    // if we're subscribed to a different request, we need to unsubscribe
+    this.removeSubscriptions();
+    // if we have a request, we need to subscribe to it
+    if (requestId) {
+      this._subscribedTo = requestId;
+      this._subscription = this.store.notifications.subscribe(requestId, (_id, op) => {
+        // ignore subscription events that occur while our own component's request
+        // is ocurring
+        if (this.isUpdating) {
+          return;
+        }
+        switch (op) {
+          case 'invalidated':
+            {
+              // if we're subscribed to invalidations, we need to update
+              if (this.autorefreshTypes.has('invalid')) {
+                this.invalidated = true;
+                this.maybeUpdate();
+              }
+              break;
+            }
+          case 'state':
+            {
+              const latest = this.store.requestManager._deduped.get(requestId);
+              const priority = latest?.priority;
+              const state = this.reqState;
+              if (!priority) {
+                // if there is no priority, we have completed whatever request
+                // was occurring and so we are no longer refreshing (if we were)
+                this.isRefreshing = false;
+              } else if (priority.blocking && !state.isLoading) {
+                // if we are blocking, there is an active request for this identity
+                // that MUST be fulfilled from network (not cache).
+                // Thus this is not "refreshing" because we should clear out and
+                // block on this request.
+                //
+                // we receive state notifications when either a request initiates
+                // or completes.
+                //
+                // In the completes case: we may receive the state notification
+                // slightly before the request is finalized because the NotificationManager
+                // may sync flush it (and thus deliver it before the microtask completes)
+                //
+                // In the initiates case: we aren't supposed to receive one unless there
+                // is no other request in flight for this identity.
+                //
+                // However, there is a race condition here where the completed
+                // notification can trigger an update that generates a new request
+                // thus giving us an initiated notification before the older request
+                // finalizes.
+                //
+                // When this occurs, if the triggered update happens to have caused
+                // a new request to be made for the same identity AND that request
+                // is the one passed into this component as the @request arg, then
+                // getRequestState will return the state of the new request.
+                // We can detect this by checking if the request state is "loading"
+                // as outside of this case we would have a completed request.
+                //
+                // That is the reason for the `&& !state.isLoading` check above.
+                // TODO should we just treat this as refreshing?
+                this.isRefreshing = false;
+                this.maybeUpdate('policy', true);
+              } else {
+                this.isRefreshing = true;
+              }
+            }
+        }
+      });
+    }
+  }
+  removeSubscriptions() {
+    if (this._subscription) {
+      this.store.notifications.unsubscribe(this._subscription);
+      this._subscribedTo = null;
+      this._subscription = null;
+    }
+  }
+  /**
+  * Install the event listeners for network and visibility changes.
+  * This is only done in browser environments with a global `window`.
+  *
+  * @internal
+  */
   installListeners() {
     if (typeof window === 'undefined') {
       return;
@@ -648,17 +855,17 @@ class Request extends Component {
     this.isOnline = window.navigator.onLine;
     this.unavailableStart = this.isOnline ? null : Date.now();
     this.isHidden = document.visibilityState === 'hidden';
-    this.onlineChanged = event1 => {
-      this.isOnline = event1.type === 'online';
-      if (event1.type === 'offline' && this.unavailableStart === null) {
+    this.onlineChanged = event => {
+      this.isOnline = event.type === 'online';
+      if (event.type === 'offline' && this.unavailableStart === null) {
         this.unavailableStart = Date.now();
       }
       this.maybeUpdate();
     };
     this.backgroundChanged = () => {
-      const isHidden1 = document.visibilityState === 'hidden';
-      this.isHidden = isHidden1;
-      if (isHidden1 && this.unavailableStart === null) {
+      const isHidden = document.visibilityState === 'hidden';
+      this.isHidden = isHidden;
+      if (isHidden && this.unavailableStart === null) {
         this.unavailableStart = Date.now();
       }
       this.maybeUpdate();
@@ -676,59 +883,112 @@ class Request extends Component {
       capture: true
     });
   }
-  maybeUpdate(mode1) {
-    if (this.isOnline && !this.isHidden && (mode1 || this.args.autorefresh)) {
-      const deadline1 = typeof this.args.autorefreshThreshold === 'number' ? this.args.autorefreshThreshold : DEFAULT_DEADLINE;
-      const shouldAttempt1 = mode1 || this.unavailableStart && Date.now() - this.unavailableStart > deadline1;
-      this.unavailableStart = null;
-      if (shouldAttempt1) {
-        const request1 = Object.assign({}, this.reqState.request);
-        const val1 = mode1 ?? this.args.autorefreshBehavior ?? 'policy';
-        switch (val1) {
-          case 'reload':
-            request1.cacheOptions = Object.assign({}, request1.cacheOptions, {
-              reload: true
-            });
-            break;
-          case 'refresh':
-            request1.cacheOptions = Object.assign({}, request1.cacheOptions, {
-              backgroundReload: true
-            });
-            break;
-          case 'policy':
-            break;
-          default:
-            throw new Error(`Invalid ${mode1 ? 'update mode' : '@autorefreshBehavior'} for <Request />: ${isNeverString(val1)}`);
-        }
-        const wasStoreRequest1 = request1[EnableHydration] === true;
-        macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
-          if (!test) {
-            throw new Error(`Cannot supply a different store via context than was used to create the request`);
-          }
-        })(!request1.store || request1.store === this.store) : {};
-        this._latestRequest = wasStoreRequest1 ? this.store.request(request1) : this.store.requestManager.request(request1);
-        if (val1 !== 'refresh') {
-          this._localRequest = this._latestRequest;
-        }
-        return;
+  /**
+  * If the network is online and the tab is visible, either reload or refresh the request
+  * based on the component's configuration and the requested update mode.
+  *
+  * Valid modes are:
+  *
+  * - `'reload'`: Force a reload of the request.
+  * - `'refresh'`: Refresh the request in the background.
+  * - `'policy'`: Make the request, letting the store's configured CachePolicy decide whether to reload, refresh, or do nothing.
+  * - `undefined`: Make the request using the component's autorefreshBehavior setting if the autorefreshThreshold has passed.
+  *
+  * @internal
+  */
+  maybeUpdate(mode, silent) {
+    if (this.isIdle) {
+      return;
+    }
+    const canAttempt = Boolean(this.isOnline && !this.isHidden && (mode || this.autorefreshTypes.size));
+    if (!canAttempt) {
+      if (!silent && mode && mode !== 'invalidated') {
+        throw new Error(`Reload not available: the network is not online or the tab is hidden`);
       }
+      return;
     }
-    if (mode1) {
-      throw new Error(`Reload not available: the network is not online or the tab is hidden`);
+    const {
+      autorefreshTypes
+    } = this;
+    let shouldAttempt = this.invalidated || Boolean(mode);
+    if (!shouldAttempt && autorefreshTypes.has('online')) {
+      const {
+        unavailableStart
+      } = this;
+      const {
+        autorefreshThreshold
+      } = this.args;
+      const deadline = typeof autorefreshThreshold === 'number' ? autorefreshThreshold : DEFAULT_DEADLINE;
+      shouldAttempt = Boolean(unavailableStart && Date.now() - unavailableStart > deadline);
+    }
+    if (!shouldAttempt && autorefreshTypes.has('interval')) {
+      const {
+        intervalStart
+      } = this;
+      const {
+        autorefreshThreshold
+      } = this.args;
+      if (intervalStart && typeof autorefreshThreshold === 'number' && autorefreshThreshold > 0) {
+        shouldAttempt = Boolean(Date.now() - intervalStart >= autorefreshThreshold);
+      }
+    }
+    this.unavailableStart = null;
+    this.invalidated = false;
+    if (shouldAttempt) {
+      this.clearInterval();
+      const request = Object.assign({}, this.reqState.request);
+      const realMode = mode === 'invalidated' ? null : mode;
+      const val = realMode ?? this.args.autorefreshBehavior ?? 'policy';
+      switch (val) {
+        case 'reload':
+          request.cacheOptions = Object.assign({}, request.cacheOptions, {
+            reload: true
+          });
+          break;
+        case 'refresh':
+          request.cacheOptions = Object.assign({}, request.cacheOptions, {
+            backgroundReload: true
+          });
+          break;
+        case 'policy':
+          break;
+        default:
+          throw new Error(`Invalid ${mode ? 'update mode' : '@autorefreshBehavior'} for <Request />: ${isNeverString(val)}`);
+      }
+      const wasStoreRequest = request[EnableHydration] === true;
+      macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+        if (!test) {
+          throw new Error(`Cannot supply a different store via context than was used to create the request`);
+        }
+      })(!request.store || request.store === this.store) : {};
+      this.isUpdating = true;
+      this._latestRequest = wasStoreRequest ? this.store.request(request) : this.store.requestManager.request(request);
+      if (val !== 'refresh') {
+        this._localRequest = this._latestRequest;
+      }
+      void this.scheduleInterval();
+      void this._latestRequest.finally(() => {
+        this.isUpdating = false;
+      });
     }
   }
+  /**
+  * Retry the request, reloading it from the server.
+  *
+  * @internal
+  */
   retry = async () => {
     this.maybeUpdate('reload');
     await this._localRequest;
   };
+  /**
+  * Refresh the request, updating it in the background.
+  *
+  * @internal
+  */
   refresh = async () => {
-    this.isRefreshing = true;
     this.maybeUpdate('refresh');
-    try {
-      await this._latestRequest;
-    } finally {
-      this.isRefreshing = false;
-    }
+    await this._latestRequest;
   };
   get errorFeatures() {
     return {
@@ -741,7 +1001,7 @@ class Request extends Component {
     decorateMethodV2(this.prototype, "errorFeatures", [cached]);
   }
   get contentFeatures() {
-    const feat1 = {
+    const feat = {
       isHidden: this.isHidden,
       isOnline: this.isOnline,
       reload: this.retry,
@@ -749,20 +1009,22 @@ class Request extends Component {
       isRefreshing: this.isRefreshing,
       latestRequest: this._latestRequest
     };
-    if (feat1.isRefreshing) {
-      feat1.abort = () => {
+    if (feat.isRefreshing) {
+      feat.abort = () => {
         this._latestRequest?.abort();
       };
     }
-    return feat1;
+    return feat;
   }
   static {
     decorateMethodV2(this.prototype, "contentFeatures", [cached]);
   }
   willDestroy() {
+    this.removeSubscriptions();
     if (typeof window === 'undefined') {
       return;
     }
+    this.clearInterval();
     window.removeEventListener('online', this.onlineChanged, {
       passive: true,
       capture: true
@@ -776,49 +1038,57 @@ class Request extends Component {
       capture: true
     });
   }
-  get request() {
+  get _request() {
     const {
-      request: request1,
-      query: query1
+      request,
+      query
     } = this.args;
     macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
       if (!test) {
         throw new Error(`Cannot use both @request and @query args with the <Request> component`);
       }
-    })(!request1 || !query1) : {};
+    })(!request || !query) : {};
     const {
-      _localRequest: _localRequest1,
-      _originalRequest: _originalRequest1,
-      _originalQuery: _originalQuery1
+      _localRequest,
+      _originalRequest,
+      _originalQuery
     } = this;
-    const isOriginalRequest1 = request1 === _originalRequest1 && query1 === _originalQuery1;
-    if (_localRequest1 && isOriginalRequest1) {
-      return _localRequest1;
+    const isOriginalRequest = request === _originalRequest && query === _originalQuery;
+    if (_localRequest && isOriginalRequest) {
+      return _localRequest;
     }
     // update state checks for the next time
-    this._originalQuery = query1;
-    this._originalRequest = request1;
-    if (request1) {
-      return request1;
+    this._originalQuery = query;
+    this._originalRequest = request;
+    if (request) {
+      return request;
     }
     macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
       if (!test) {
         throw new Error(`You must provide either @request or an @query arg with the <Request> component`);
       }
-    })(query1) : {};
-    return this.store.request(query1);
+    })(query) : {};
+    return this.store.request(query);
+  }
+  static {
+    decorateMethodV2(this.prototype, "_request", [cached]);
+  }
+  get request() {
+    const request = this._request;
+    this.updateSubscriptions();
+    return request;
   }
   static {
     decorateMethodV2(this.prototype, "request", [cached]);
   }
   get store() {
-    const store1 = this.args.store || this._store;
+    const store = this.args.store || this._store;
     macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
       if (!test) {
         throw new Error(moduleExists('ember-provide-consume-context') ? `No store was provided to the <Request> component. Either provide a store via the @store arg or via the context API provided by ember-provide-consume-context.` : `No store was provided to the <Request> component. Either provide a store via the @store arg or by registering a store service.`);
       }
-    })(store1) : {};
-    return store1;
+    })(store) : {};
+    return store;
   }
   get reqState() {
     return getRequestState(this.request);
@@ -827,13 +1097,14 @@ class Request extends Component {
     return this.reqState.result;
   }
   static {
-    setComponentTemplate(precompileTemplate("\n    {{#if this.reqState.isLoading}}\n      {{yield this.reqState.loadingState to=\"loading\"}}\n    {{else if (and this.reqState.isCancelled (has-block \"cancelled\"))}}\n      {{yield (notNull this.reqState.error) this.errorFeatures to=\"cancelled\"}}\n    {{else if (and this.reqState.isError (has-block \"error\"))}}\n      {{yield (notNull this.reqState.error) this.errorFeatures to=\"error\"}}\n    {{else if this.reqState.isSuccess}}\n      {{yield this.result this.contentFeatures to=\"content\"}}\n    {{else if (not this.reqState.isCancelled)}}\n      <Throw @error={{(notNull this.reqState.error)}} />\n    {{/if}}\n    {{yield this.reqState to=\"always\"}}\n  ", {
+    setComponentTemplate(precompileTemplate("\n    {{#if (and this.isIdle (has-block \"idle\"))}}\n      {{yield to=\"idle\"}}\n    {{else if this.isIdle}}\n      <Throw @error={{IdleBlockMissingError}} />\n    {{else if this.reqState.isLoading}}\n      {{yield this.reqState.loadingState to=\"loading\"}}\n    {{else if (and this.reqState.isCancelled (has-block \"cancelled\"))}}\n      {{yield (notNull this.reqState.error) this.errorFeatures to=\"cancelled\"}}\n    {{else if (and this.reqState.isError (has-block \"error\"))}}\n      {{yield (notNull this.reqState.error) this.errorFeatures to=\"error\"}}\n    {{else if this.reqState.isSuccess}}\n      {{yield this.result this.contentFeatures to=\"content\"}}\n    {{else if (not this.reqState.isCancelled)}}\n      <Throw @error={{(notNull this.reqState.error)}} />\n    {{/if}}\n    {{yield this.reqState to=\"always\"}}\n  ", {
       strictMode: true,
       scope: () => ({
         and,
+        Throw,
+        IdleBlockMissingError,
         notNull,
-        not,
-        Throw
+        not
       })
     }), this);
   }