@warp-drive-mirror/ember 5.6.0-alpha.15 → 5.6.0-alpha.18

package/declarations/index.d.ts

@@ -1,216 +1,215 @@
 /**
- * <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-mirror/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-mirror/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-mirror/ember';
- * ```
- *
- * ```hbs
- * <WarpDriveAwait @promise={{this.getTheData}}></WarpDriveAwait>
- * ```
- *
- * @module
- */
-export { Request } from './-private/request.gts';
-export { Await, Throw } from './-private/await.gts';
+* <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-mirror/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-mirror/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-mirror/ember';
+* ```
+*
+* ```hbs
+* <WarpDriveAwait @promise={{this.getTheData}}></WarpDriveAwait>
+* ```
+*
+* @module
+*/
+export { Request } from "./-private/request.js";
+export { Await, Throw } from "./-private/await.js";
 /**
- * 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
- */
+* 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-mirror/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-mirror/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.
+* 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-mirror/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-mirror/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 '@warp-drive-mirror/core/store/-private';
+* @public
+* @param {Promise<T> | Awaitable<T, E>} promise
+* @return {PromiseState<T, E>}
+*/
+export { getPromiseState } from "@warp-drive-mirror/core/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
- */
+* 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
- */
+* 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-mirror/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-mirror/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 '@warp-drive-mirror/core/store/-private';
-//# sourceMappingURL=index.d.ts.map
+*
+*
+* `getRequestState` can be used in both JavaScript and Template contexts.
+*
+* ```ts
+* import { getRequestState } from '@warp-drive-mirror/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-mirror/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 "@warp-drive-mirror/core/store/-private";

package/declarations/install.d.ts

@@ -1,16 +1,6 @@
-import { tagForProperty } from '@ember/-internals/metal';
-type Tag = ReturnType<typeof tagForProperty>;
+import type { SignalHooks } from "@warp-drive-mirror/core/store/-private";
 export declare function buildSignalConfig(options: {
-    wellknown: {
-        Array: symbol | string;
-    };
-}): {
-    createSignal(obj: object, key: string | symbol): Tag | [Tag, Tag, 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;
-    waitFor: <K>(promise: Promise<K>) => Promise<K>;
-};
-export {};
-//# sourceMappingURL=install.d.ts.map
+	wellknown: {
+		Array: symbol | string;
+	};
+}): SignalHooks;

package/dist/index.js

@@ -431,4 +431,3 @@ class Request extends Component {
 }
 
 export { Await, Request, Throw };
-//# sourceMappingURL=index.js.map

package/dist/install.js

@@ -75,4 +75,3 @@ function buildSignalConfig(options) {
 setupSignals(buildSignalConfig);
 
 export { buildSignalConfig };
-//# sourceMappingURL=install.js.map

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@warp-drive-mirror/ember",
   "description": "Data bindings and utilities for Ember applications using WarpDrive",
-  "version": "5.6.0-alpha.15",
+  "version": "5.6.0-alpha.18",
   "license": "MIT",
   "author": "Chris Thoburn <runspired@users.noreply.github.com>",
   "repository": {
@@ -38,7 +38,7 @@
   },
   "dependencies": {
     "@embroider/macros": "^1.16.12",
-    "@warp-drive-mirror/core": "5.6.0-alpha.15"
+    "@warp-drive-mirror/core": "5.6.0-alpha.18"
   },
   "peerDependenciesMeta": {
     "ember-provide-consume-context": {
@@ -60,14 +60,14 @@
     "@embroider/addon-dev": "^7.1.3",
     "@ember/test-helpers": "5.2.0",
     "@ember/test-waiters": "^4.1.0",
-    "@warp-drive/internal-config": "5.6.0-alpha.15",
-    "@warp-drive-mirror/core": "5.6.0-alpha.15",
+    "@warp-drive/internal-config": "5.6.0-alpha.18",
+    "@warp-drive-mirror/core": "5.6.0-alpha.18",
     "babel-plugin-ember-template-compilation": "^2.4.1",
     "ember-template-imports": "^4.3.0",
     "ember-source": "~6.3.0",
     "rollup": "^4.40.0",
     "typescript": "^5.8.3",
-    "vite": "^5.4.15",
+    "vite": "^7.0.0",
     "ember-provide-consume-context": "^0.7.0"
   },
   "volta": {

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

@@ -1,77 +0,0 @@
-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

@@ -1 +0,0 @@
-{"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"}