@warp-drive-mirror/ember 5.6.0-alpha.0 → 5.6.0-alpha.11

package/README.md

@@ -74,7 +74,7 @@ you should load data based on user interactions and route navigations, not from
 but what if you didn't need to use prop-drilling or contexts to access the result of a
 route based query?
 
-EmberData's RequestManager already allows for fulfillment from cache and for request 
+WarpDrive's RequestManager already allows for fulfillment from cache and for request 
 de-duping, so what if we could just pick up where we left off and use the result of a
 request right away if it already was fetched elsewhere?
 

package/addon-main.cjs

@@ -1,5 +1,5 @@
 'use strict';
 
-const { addonShim } = require('@warp-drive-mirror/build-config/addon-shim.cjs');
+const { addonShim } = require('@warp-drive-mirror/core/addon-shim.cjs');
 
 module.exports = addonShim(__dirname);

package/declarations/-private/await.gts.d.ts

@@ -0,0 +1,77 @@
+import type Owner from '@ember/owner';
+import Component from '@glimmer/component';
+import type { Awaitable } from '@warp-drive-mirror/core/request';
+export declare const and: (x: unknown, y: unknown) => boolean;
+interface ThrowSignature<E = Error | string | object> {
+    Args: {
+        error: E;
+    };
+}
+/**
+ * The `<Throw />` component is used to throw an error in a template.
+ *
+ * That's all it does. So don't use it unless the application should
+ * throw an error if it reaches this point in the template.
+ *
+ * ```hbs
+ * <Throw @error={{anError}} />
+ * ```
+ *
+ * @class <Throw />
+ * @public
+ */
+export declare class Throw<T> extends Component<ThrowSignature<T>> {
+    constructor(owner: Owner, args: ThrowSignature<T>['Args']);
+}
+interface AwaitSignature<T, E = Error | string | object> {
+    Args: {
+        promise: Promise<T> | Awaitable<T, E>;
+    };
+    Blocks: {
+        pending: [];
+        error: [error: E];
+        success: [value: T];
+    };
+}
+/**
+ * The <Await /> component allow you to utilize reactive control flow
+ * for asynchronous states in your application.
+ *
+ * Await is ideal for handling "boundaries", outside which some state is
+ * still allowed to be unresolved and within which it MUST be resolved.
+ *
+ * ```gjs
+ * import { Await } from '@warp-drive-mirror/ember';
+ *
+ * <template>
+ *   <Await @promise={{@request}}>
+ *     <:pending>
+ *       <Spinner />
+ *     </:pending>
+ *
+ *     <:error as |error|>
+ *       <ErrorForm @error={{error}} />
+ *     </:error>
+ *
+ *     <:success as |result|>
+ *       <h1>{{result.title}}</h1>
+ *     </:success>
+ *   </Await>
+ * </template>
+ * ```
+ *
+ * The <Await /> component requires that error states are properly handled.
+ *
+ * If no error block is provided and the promise rejects, the error will
+ * be thrown.
+ *
+ * @class <Await />
+ * @public
+ */
+export declare class Await<T, E> extends Component<AwaitSignature<T, E>> {
+    get state(): Readonly<import("@warp-drive-mirror/core/store/-private").PromiseState<T, E>>;
+    get error(): E;
+    get result(): T;
+}
+export {};
+//# sourceMappingURL=await.gts.d.ts.map

package/declarations/-private/await.gts.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"await.gts.d.ts","sourceRoot":"","sources":["../../src/-private/await.gts"],"names":[],"mappings":"AAAA,OA4GO,KAAK,KAAK,MAAM,cAAc,CAAC;AACtC,OAAO,SAAS,MAAM,oBAAoB,CAAC;AAE3C,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,0BAA0B,CAAC;AAG1D,eAAO,MAAM,GAAG,GAAI,GAAG,OAAO,EAAE,GAAG,OAAO,YAAoB,CAAC;AAC/D,UAAU,cAAc,CAAC,CAAC,GAAG,KAAK,GAAG,MAAM,GAAG,MAAM;IAClD,IAAI,EAAE;QACJ,KAAK,EAAE,CAAC,CAAC;KACV,CAAC;CACH;AAED;;;;;;;;;;;;GAYG;AACH,qBAAa,KAAK,CAAC,CAAC,CAAE,SAAQ,SAAS,CAAC,cAAc,CAAC,CAAC,CAAC,CAAC;gBAC5C,KAAK,EAAE,KAAK,EAAE,IAAI,EAAE,cAAc,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC;CAU1D;AAED,UAAU,cAAc,CAAC,CAAC,EAAE,CAAC,GAAG,KAAK,GAAG,MAAM,GAAG,MAAM;IACrD,IAAI,EAAE;QACJ,OAAO,EAAE,OAAO,CAAC,CAAC,CAAC,GAAG,SAAS,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;KACvC,CAAC;IACF,MAAM,EAAE;QACN,OAAO,EAAE,EAAE,CAAC;QACZ,KAAK,EAAE,CAAC,KAAK,EAAE,CAAC,CAAC,CAAC;QAClB,OAAO,EAAE,CAAC,KAAK,EAAE,CAAC,CAAC,CAAC;KACrB,CAAC;CACH;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkCG;AACH,qBAAa,KAAK,CAAC,CAAC,EAAE,CAAC,CAAE,SAAQ,SAAS,CAAC,cAAc,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;IAC9D,IAAI,KAAK,2EAER;IAED,IAAI,KAAK,IACoB,CAAC,CAC7B;IAED,IAAI,MAAM,IACoB,CAAC,CAC9B;CAyBF"}

package/declarations/-private/request.gts.d.ts

@@ -0,0 +1,486 @@
+import type Owner from '@ember/owner';
+import Component from '@glimmer/component';
+import type { Store, StoreRequestInput } from '@warp-drive-mirror/core';
+import type { Future } from '@warp-drive-mirror/core/request';
+import type { RequestLoadingState, RequestState } from '@warp-drive-mirror/core/store/-private';
+import type { StructuredErrorDocument } from '@warp-drive-mirror/core/types/request';
+type AutorefreshBehaviorType = 'online' | 'interval' | 'invalid';
+type AutorefreshBehaviorCombos = boolean | AutorefreshBehaviorType | `${AutorefreshBehaviorType},${AutorefreshBehaviorType}` | `${AutorefreshBehaviorType},${AutorefreshBehaviorType},${AutorefreshBehaviorType}`;
+type ContentFeatures<RT> = {
+    isOnline: boolean;
+    isHidden: boolean;
+    isRefreshing: boolean;
+    refresh: () => Promise<void>;
+    reload: () => Promise<void>;
+    abort?: () => void;
+    latestRequest?: Future<RT>;
+};
+interface RequestSignature<RT, T, E> {
+    Args: {
+        /**
+         * The request to monitor. This should be a `Future` instance returned
+         * by either the `store.request` or `store.requestManager.request` methods.
+         *
+         */
+        request?: Future<RT>;
+        /**
+         * A query to use for the request. This should be an object that can be
+         * passed to `store.request`. Use this in place of `@request` if you would
+         * like the component to also initiate the request.
+         *
+         */
+        query?: StoreRequestInput<RT, T>;
+        /**
+         * The store instance to use for making requests. If contexts are available,
+         * the component will default to using the `store` on the context.
+         *
+         * This is required if the store is not available via context or should be
+         * different from the store provided via context.
+         *
+         */
+        store?: Store;
+        /**
+         * The autorefresh behavior for the request. This can be a boolean, or any
+         * combination of the following values: `'online'`, `'interval'`, `'invalid'`.
+         *
+         * - `'online'`: Refresh the request when the browser comes back online
+         * - `'interval'`: Refresh the request at a specified interval
+         * - `'invalid'`: Refresh the request when the store emits an invalidation
+         *
+         * If `true`, this is equivalent to `'online,invalid'`.
+         *
+         * Defaults to `false`.
+         *
+         */
+        autorefresh?: AutorefreshBehaviorCombos;
+        /**
+         * The number of milliseconds to wait before refreshing the request when the
+         * browser comes back online or the network becomes available.
+         *
+         * This also controls the interval at which the request will be refreshed if
+         * the `interval` autorefresh type is enabled.
+         *
+         * Defaults to `30_000` (30 seconds).
+         *
+         */
+        autorefreshThreshold?: number;
+        /**
+         * The behavior of the request initiated by autorefresh. This can be one of
+         * the following values:
+         *
+         * - `'refresh'`: Refresh the request in the background
+         * - `'reload'`: Force a reload of the request
+         * - `'policy'` (**default**): Let the store's configured CachePolicy decide whether to
+         *    reload, refresh, or do nothing.
+         *
+         * Defaults to `'policy'`.
+         *
+         */
+        autorefreshBehavior?: 'refresh' | 'reload' | 'policy';
+    };
+    Blocks: {
+        /**
+         * The block to render when the component is idle and waiting to be given a request.
+         *
+         */
+        idle: [];
+        /**
+         * The block to render when the request is loading.
+         *
+         */
+        loading: [state: RequestLoadingState];
+        /**
+         * The block to render when the request was cancelled.
+         *
+         */
+        cancelled: [
+            error: StructuredErrorDocument<E>,
+            features: {
+                isOnline: boolean;
+                isHidden: boolean;
+                retry: () => Promise<void>;
+            }
+        ];
+        /**
+         * The block to render when the request failed. If this block is not provided,
+         * the error will be rethrown.
+         *
+         * Thus it is required to provide an error block and proper error handling if
+         * you do not want the error to crash the application.
+         *
+         */
+        error: [
+            error: StructuredErrorDocument<E>,
+            features: {
+                isOnline: boolean;
+                isHidden: boolean;
+                retry: () => Promise<void>;
+            }
+        ];
+        /**
+         * The block to render when the request succeeded.
+         *
+         */
+        content: [value: RT, features: ContentFeatures<RT>];
+        always: [state: RequestState<RT, T, StructuredErrorDocument<E>>];
+    };
+}
+/**
+ * The `<Request />` component is a powerful tool for managing data fetching and
+ * state in your Ember application. It provides a declarative approach to reactive
+ * control-flow for managing requests and state in your application.
+ *
+ * The `<Request />` component is ideal for handling "boundaries", outside which some
+ * state is still allowed to be unresolved and within which it MUST be resolved.
+ *
+ * ## Request States
+ *
+ * `<Request />` has five states, only one of which will be active and rendered at a time.
+ *
+ * - `idle`: The component is waiting to be given a request to monitor
+ * - `loading`: The request is in progress
+ * - `error`: The request failed
+ * - `content`: The request succeeded
+ * - `cancelled`: The request was cancelled
+ *
+ * Additionally, the `content` state has a `refresh` method that can be used to
+ * refresh the request in the background, which is available as a sub-state of
+ * the `content` state.
+ *
+ * As with the `<Await />` component, if no error block is provided and the request
+ * rejects, the error will be thrown. Cancellation errors are swallowed instead of
+ * rethrown if no error block or cancellation block is present.
+ *
+ * ```gts
+ * import { Request } from '@warp-drive-mirror/ember';
+ *
+ * <template>
+ *   <Request @request={{@request}}>
+ *     <:loading as |state|>
+ *       <Spinner @percentDone={{state.completedRatio}} />
+ *       <button {{on "click" state.abort}}>Cancel</button>
+ *     </:loading>
+ *
+ *     <:error as |error state|>
+ *       <ErrorForm @error={{error}} />
+ *       <button {{on "click" state.retry}}>Retry</button>
+ *     </:error>
+ *
+ *     <:content as |data state|>
+ *       <h1>{{data.title}}</h1>
+ *       {{#if state.isBackgroundReloading}}
+ *         <SmallSpinner />
+ *         <button {{on "click" state.abort}}>Cancel</button>
+ *       {{else}}
+ *         <button {{on "click" state.refresh}}>Refresh</button>
+ *       {{/if}}
+ *     </:content>
+ *
+ *     <:cancelled as |error state|>
+ *       <h2>The Request was cancelled</h2>
+ *       <button {{on "click" state.retry}}>Retry</button>
+ *     </:cancelled>
+ *
+ *     <:idle>
+ *       <button {{on "click" @kickOffRequest}}>Load Preview?</button>
+ *     </:idle>
+ *
+ *   </Request>
+ * </template>
+ * ```
+ *
+ * ## Streaming Data
+ *
+ * The loading state exposes the download `ReadableStream` instance for consumption
+ *
+ * ```gjs
+ * import { Request } from '@warp-drive-mirror/ember';
+ *
+ * <template>
+ *   <Request @request={{@request}}>
+ *     <:loading as |state|>
+ *       <Video @stream={{state.stream}} />
+ *     </:loading>
+ *
+ *     <:error as |error|>
+ *       <ErrorForm @error={{error}} />
+ *     </:error>
+ *   </Request>
+ * </template>
+ * ```
+ *
+ * ## Retry
+ *
+ * Cancelled and error'd requests may be retried by calling the `retry` method.
+ *
+ * Retry will restart the state progression, using the loading, error, cancelled,
+ * and content blocks as appropriate.
+ *
+ * ## Reloading
+ *
+ * The `reload` method will force the request to be fully re-executed, bypassing
+ * cache and restarting the state progression through the loading, error, and
+ * content blocks as appropriate.
+ *
+ * Background reload (refresh) is a special substate of the content state that
+ * allows you to refresh the request in the background. This is useful for when
+ * you want to update the data in the background without blocking the UI.
+ *
+ * Reload and refresh are available as methods on the `content` state.
+ *
+ * ```gjs
+ * import { Request } from '@warp-drive-mirror/ember';
+ *
+ * <template>
+ *   <Request @request={{@request}}>
+ *     <:content as |data state|>
+ *       <h1>{{data.title}}</h1>
+ *       {{#if state.isBackgroundReloading}}
+ *         <SmallSpinner />
+ *         <button {{on "click" state.abort}}>Cancel</button>
+ *       {{/if}}
+ *
+ *       <button {{on "click" state.refresh}}>Refresh</button>
+ *       <button {{on "click" state.reload}}>Reload</button>
+ *     </:content>
+ *  </Request>
+ * </template>
+ * ```
+ *
+ * ## Advanced Reloading
+ *
+ * We can nest our usage of `<Request />` to handle more advanced
+ * reloading scenarios.
+ *
+ * ```gjs
+ * import { Request } from '@warp-drive-mirror/ember';
+ *
+ * <template>
+ *   <Request @request={{@request}}>
+ *     <:cancelled>
+ *       <h2>The Request Cancelled</h2>
+ *     </:cancelled>
+ *
+ *     <:error as |error|>
+ *       <ErrorForm @error={{error}} />
+ *     </:error>
+ *
+ *     <:content as |result state|>
+ *       <Request @request={{state.latestRequest}}>
+ *         <!-- Handle Background Request -->
+ *       </Request>
+ *
+ *       <h1>{{result.title}}</h1>
+ *
+ *       <button {{on "click" state.refresh}}>Refresh</button>
+ *     </:content>
+ *   </Request>
+ * </template>
+ * ```
+ *
+ * ## Autorefresh
+ *
+ * `<Request />` supports automatic refresh and reload under certain conditions.
+ *
+ * - `online`: This occurs when a browser window or tab comes back to the foreground
+ *   after being backgrounded or when the network reports as being online after
+ *   having been offline.
+ * - `interval`: This occurs when a specified amount of time has passed.
+ * - `invalid`: This occurs when the store emits a notification that the request
+ *   has become invalid.
+ *
+ * You can specify when autorefresh should occur by setting the `autorefresh` arg
+ * to `true` or a comma-separated list of the above values.
+ *
+ * A value of `true` is equivalent to `'online,invalid'`.
+ *
+ * By default, an autorefresh will only occur if the browser was backgrounded or
+ * offline for more than 30s before coming back available. This amount of time can
+ * be tweaked by setting the number of milliseconds via `@autorefreshThreshold`.
+ *
+ * This arg also controls the interval at which the request will be refreshed
+ * if the `interval` autorefresh type is enabled.
+ *
+ * Finally, the behavior of the request initiated by autorefresh can be adjusted
+ * by setting the `autorefreshBehavior` arg to `'refresh'`, `'reload'`, or `'policy'`.
+ *
+ * - `'refresh'`: Refresh the request in the background
+ * - `'reload'`: Force a reload of the request
+ * - `'policy'` (**default**): Let the store's configured CachePolicy decide whether to
+ *    reload, refresh, or do nothing.
+ *
+ * More advanced refresh and reload behaviors can be created by passing the reload and
+ * refresh actions into another component. For instance, refresh could be set up on a
+ * timer or on a websocket subscription.
+ *
+ *
+ * ```gjs
+ * import { Request } from '@warp-drive-mirror/ember';
+ *
+ * <template>
+ *   <Request @request={{@request}}>
+ *     <:content as |result state|>
+ *       <h1>{{result.title}}</h1>
+ *
+ *       <Interval @period={{30_000}} @fn={{state.refresh}} />
+ *       <Subscribe @channel={{@someValue}} @fn={{state.refresh}} />
+ *     </:content>
+ *   </Request>
+ * </template>
+ * ```
+ *
+ * If a matching request is refreshed or reloaded by any other component,
+ * the `Request` component will react accordingly.
+ *
+ * ## Deduping
+ *
+ * The store dedupes requests by identity. If a request is made for the same identity
+ * from multiple `<Request />` components, even if the request is not referentially the
+ * same, only one actual request will be made.
+ *
+ *
+ * @class <Request />
+ * @public
+ */
+export declare class Request<RT, T, E> extends Component<RequestSignature<RT, T, E>> {
+    /**
+     * 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
+     */
+    _store: Store;
+    /**
+     * Whether the browser reports that the network is online.
+     *
+     * @internal
+     */
+    isOnline: boolean;
+    /**
+     * Whether the browser reports that the tab is hidden.
+     *
+     * @internal
+     */
+    isHidden: boolean;
+    /**
+     * Whether the component is currently refreshing the request.
+     *
+     * @internal
+     */
+    isRefreshing: boolean;
+    /**
+     * 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
+     */
+    _localRequest: Future<RT> | undefined;
+    /**
+     * 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
+     */
+    _latestRequest: Future<RT> | undefined;
+    /**
+     * The time at which the network was reported as offline.
+     *
+     * @internal
+     */
+    unavailableStart: number | null;
+    intervalStart: number | null;
+    nextInterval: number | null;
+    invalidated: boolean;
+    isUpdating: boolean;
+    /**
+     * The event listener for network status changes,
+     * cached to use the reference for removal.
+     *
+     * @internal
+     */
+    onlineChanged: (event: Event) => void;
+    /**
+     * The event listener for visibility status changes,
+     * cached to use the reference for removal.
+     *
+     * @internal
+     */
+    backgroundChanged: (event: Event) => void;
+    /**
+     * The last request passed as an arg to the component,
+     * cached for comparison.
+     *
+     * @internal
+     */
+    _originalRequest: Future<RT> | undefined;
+    /**
+     * The last query passed as an arg to the component,
+     * cached for comparison.
+     *
+     * @internal
+     */
+    _originalQuery: StoreRequestInput<RT, T> | undefined;
+    _subscription: object | null;
+    _subscribedTo: object | null;
+    constructor(owner: Owner, args: RequestSignature<RT, T, E>['Args']);
+    beginPolling(): Promise<void>;
+    get isIdle(): boolean;
+    get autorefreshTypes(): Set<AutorefreshBehaviorType>;
+    scheduleInterval(): Promise<void>;
+    clearInterval(): void;
+    updateSubscriptions(): void;
+    removeSubscriptions(): void;
+    /**
+     * Install the event listeners for network and visibility changes.
+     * This is only done in browser environments with a global `window`.
+     *
+     * @internal
+     */
+    installListeners(): void;
+    /**
+     * 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?: 'reload' | 'refresh' | 'policy' | 'invalidated', silent?: boolean): void;
+    /**
+     * Retry the request, reloading it from the server.
+     *
+     * @internal
+     */
+    retry: () => Promise<void>;
+    /**
+     * Refresh the request, updating it in the background.
+     *
+     * @internal
+     */
+    refresh: () => Promise<void>;
+    get errorFeatures(): {
+        isHidden: boolean;
+        isOnline: boolean;
+        retry: () => Promise<void>;
+    };
+    get contentFeatures(): ContentFeatures<RT>;
+    willDestroy(): void;
+    get _request(): Future<RT>;
+    get request(): Future<RT>;
+    get store(): Store;
+    get reqState(): Readonly<RequestState<RT, T, StructuredErrorDocument<E>>>;
+    get result(): RT;
+}
+export {};
+//# sourceMappingURL=request.gts.d.ts.map

package/declarations/-private/request.gts.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"request.gts.d.ts","sourceRoot":"","sources":["../../src/-private/request.gts"],"names":[],"mappings":"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"}