@warp-drive/ember 5.6.0-alpha.5 → 5.6.0-beta.1

package/unstable-preview-types/index.d.ts

@@ -1,221 +0,0 @@
-/// <reference path="./install.d.ts" />
-/// <reference path="./-private/await.gts.d.ts" />
-/// <reference path="./-private/request.gts.d.ts" />
-declare module '@warp-drive/ember' {
-  /**
-   * <h3 align="center">⚛️ Data utilities for using <em style="color: lightgreen">Warp</em><strong style="color: magenta">Drive</strong> with 🐹 <em style="color: orange">Ember</em><em style="color: lightblue">.js</em></h3>
-   *
-   * ## Installation
-   *
-   * ```cli
-   * pnpm install @warp-drive/ember
-   * ```
-   *
-   * ## About
-   *
-   * This library provides reactive utilities for working with promises
-   * and requests, building over these primitives to provide functions
-   * and components that enable you to build robust performant apps with
-   * elegant control flow.
-   *
-   * ## Using .hbs
-   *
-   * The components and utils this library exports are intended for use with Glimmer
-   * Flavored JavaScript (gjs). To use them in handlebars files, your app should re-
-   * export them. For instance:
-   *
-   * *app/components/await.ts*
-   * ```ts
-   * export { Await as default } from '@warp-drive/ember';
-   * ```
-   *
-   * ```hbs
-   * <Await @promise={{this.getTheData}}></Await>
-   * ```
-   *
-   * This allows renaming them to avoid conflicts just by using a different filename
-   * if desired:
-   *
-   * *app/components/warp-drive-await.ts*
-   * ```ts
-   * export { Await as default } from '@warp-drive/ember';
-   * ```
-   *
-   * ```hbs
-   * <WarpDriveAwait @promise={{this.getTheData}}></WarpDriveAwait>
-   * ```
-   *
-   * @module
-   */
-  export { Request } from './-private/request';
-  export { Await, Throw } from './-private/await';
-  /**
-   * PromiseState provides a reactive wrapper for a promise which allows you write declarative
-   * code around a promise's control flow. It is useful in both Template and JavaScript contexts,
-   * allowing you to quickly derive behaviors and data from pending, error and success states.
-   *
-   * ```ts
-   * interface PromiseState<T = unknown, E = unknown> {
-   *   isPending: boolean;
-   *   isSuccess: boolean;
-   *   isError: boolean;
-   *   result: T | null;
-   *   error: E | null;
-   * }
-   * ```
-   *
-   * To get the state of a promise, use `getPromiseState`.
-   *
-   * @class PromiseState
-   * @public
-   */
-  /**
-   * Returns a reactive state-machine for the provided promise or awaitable.
-   *
-   * Repeat calls to `getPromiseState` with the same promise will return the same state object
-   * making is safe and easy to use in templates and JavaScript code to produce reactive
-   * behaviors around promises.
-   *
-   * `getPromiseState` can be used in both JavaScript and Template contexts.
-   *
-   * ```ts
-   * import { getPromiseState } from '@warp-drive/ember';
-   *
-   * const state = getPromiseState(promise);
-   * ```
-   *
-   * For instance, we could write a getter on a component that updates whenever
-   * the promise state advances or the promise changes, by combining the function
-   * with the use of `@cached`
-   *
-   * ```ts
-   * class Component {
-   *   @cached
-   *   get title() {
-   *     const state = getPromiseState(this.args.request);
-   *     if (state.isPending) {
-   *       return 'loading...';
-   *     }
-   *     if (state.isError) { return null; }
-   *     return state.result.title;
-   *   }
-   * }
-   * ```
-   *
-   * Or in a template as a helper:
-   *
-   * ```gjs
-   * import { getPromiseState } from '@warp-drive/ember';
-   *
-   * <template>
-   *   {{#let (getPromiseState @request) as |state|}}
-   *     {{#if state.isPending}} <Spinner />
-   *     {{else if state.isError}} <ErrorForm @error={{state.error}} />
-   *     {{else}}
-   *       <h1>{{state.result.title}}</h1>
-   *     {{/if}}
-   *   {{/let}}
-   * </template>
-   * ```
-   *
-   * If looking to use in a template, consider also the `<Await />` component.
-  
-   * @public
-   * @param {Promise<T> | Awaitable<T, E>} promise
-   * @return {PromiseState<T, E>}
-   */
-  export { getPromiseState } from '@ember-data/store/-private';
-  /**
-   * Lazily consumes the stream of a request, providing a number of
-   * reactive properties that can be used to build UIs that respond
-   * to the progress of a request.
-   *
-   * @class RequestLoadingState
-   * @public
-   */
-  /**
-   * RequestState extends the concept of PromiseState to provide a reactive
-   * wrapper for a request `Future` which allows you write declarative code
-   * around a Future's control flow.
-   *
-   * It is useful in both Template and JavaScript contexts, allowing you
-   * to quickly derive behaviors and data from pending, error and success
-   * states.
-   *
-   * The key difference between a Promise and a Future is that Futures provide
-   * access to a stream of their content, the identity of the request (if any)
-   * as well as the ability to attempt to abort the request.
-   *
-   * ```ts
-   * interface Future<T> extends Promise<T>> {
-   *   getStream(): Promise<ReadableStream>;
-   *   abort(): void;
-   *   lid: StableDocumentIdentifier | null;
-   * }
-   * ```
-   *
-   * These additional APIs allow us to craft even richer state experiences.
-   *
-   * To get the state of a request, use `getRequestState`.
-   *
-   * @class RequestState
-   * @public
-   */
-  /**
-   *
-   *
-   * `getRequestState` can be used in both JavaScript and Template contexts.
-   *
-   * ```ts
-   * import { getRequestState } from '@warp-drive/ember';
-   *
-   * const state = getRequestState(future);
-   * ```
-   *
-   * For instance, we could write a getter on a component that updates whenever
-   * the request state advances or the future changes, by combining the function
-   * with the use of `@cached`
-   *
-   * ```ts
-   * class Component {
-   *   @cached
-   *   get title() {
-   *     const state = getRequestState(this.args.request);
-   *     if (state.isPending) {
-   *       return 'loading...';
-   *     }
-   *     if (state.isError) { return null; }
-   *     return state.result.title;
-   *   }
-   * }
-   * ```
-   *
-   * Or in a template as a helper:
-   *
-   * ```gjs
-   * import { getRequestState } from '@warp-drive/ember';
-   *
-   * <template>
-   *   {{#let (getRequestState @request) as |state|}}
-   *     {{#if state.isPending}}
-   *       <Spinner />
-   *     {{else if state.isError}}
-   *       <ErrorForm @error={{state.error}} />
-   *     {{else}}
-   *       <h1>{{state.result.title}}</h1>
-   *     {{/if}}
-   *   {{/let}}
-   * </template>
-   * ```
-   *
-   * If looking to use in a template, consider also the `<Request />` component
-   * which offers a numbe of additional capabilities for requests *beyond* what
-   * `RequestState` provides.
-   *
-   * @public
-   * @param future
-   * @return {RequestState}
-   */
-  export { getRequestState, type RequestLoadingState } from '@ember-data/store/-private';
-}
-//# sourceMappingURL=index.d.ts.map

package/unstable-preview-types/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4CG;AACH,OAAO,EAAE,OAAO,EAAE,MAAM,wBAAwB,CAAC;AACjD,OAAO,EAAE,KAAK,EAAE,KAAK,EAAE,MAAM,sBAAsB,CAAC;AAEpD;;;;;;;;;;;;;;;;;;;GAmBG;AAEH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsDG;AACH,OAAO,EAAE,eAAe,EAAE,MAAM,4BAA4B,CAAC;AAE7D;;;;;;;GAOG;AAEH;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AAEH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsDG;AACH,OAAO,EAAE,eAAe,EAAE,KAAK,mBAAmB,EAAE,MAAM,4BAA4B,CAAC"}

package/unstable-preview-types/install.d.ts

@@ -1,17 +0,0 @@
-declare module '@warp-drive/ember/install' {
-  import { tagForProperty } from '@ember/-internals/metal';
-  type Tag = ReturnType<typeof tagForProperty>;
-  export function buildSignalConfig(options: {
-      wellknown: {
-          Array: symbol | string;
-      };
-  }): {
-      createSignal(obj: object, key: string | symbol): import("@glimmer/validator").Tag | [import("@glimmer/validator").Tag, import("@glimmer/validator").Tag, import("@glimmer/validator").Tag];
-      consumeSignal(signal: Tag | [Tag, Tag, Tag]): void;
-      notifySignal(signal: Tag | [Tag, Tag, Tag]): void;
-      createMemo: <F>(object: object, key: string | symbol, fn: () => F) => (() => F);
-      willSyncFlushWatchers: () => boolean;
-  };
-  export {};
-}
-//# sourceMappingURL=install.d.ts.map

package/unstable-preview-types/install.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"install.d.ts","sourceRoot":"","sources":["../src/install.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,MAAM,yBAAyB,CAAC;AASzD,KAAK,GAAG,GAAG,UAAU,CAAC,OAAO,cAAc,CAAC,CAAC;AAG7C,wBAAgB,iBAAiB,CAAC,OAAO,EAAE;IACzC,SAAS,EAAE;QACT,KAAK,EAAE,MAAM,GAAG,MAAM,CAAC;KACxB,CAAC;CACH;sBAIqB,MAAM,OAAO,MAAM,GAAG,MAAM;0BAQxB,GAAG,GAAG,CAAC,GAAG,EAAE,GAAG,EAAE,GAAG,CAAC;yBAYtB,GAAG,GAAG,CAAC,GAAG,EAAE,GAAG,EAAE,GAAG,CAAC;iBAW7B,CAAC,UAAU,MAAM,OAAO,MAAM,GAAG,MAAM,MAAM,MAAM,CAAC,KAAG,CAAC,MAAM,CAAC,CAAC;;EAwBhF"}