@warp-drive/core 5.6.0-alpha.15 → 5.6.0-alpha.17

package/declarations/store/-private/new-core-tmp/reactivity/signal.d.ts

@@ -1,30 +1,35 @@
-import type { SignalStore, WarpDriveSignal } from './internal.ts';
+import type { SignalStore, WarpDriveSignal } from "./internal.js";
 /**
- * Creates a signal for the key/object pairing and subscribes to the signal.
- *
- * Use when you need to ensure a signal exists and is subscribed to.
- *
- * @internal
- */
+* Creates a signal for the key/object pairing and subscribes to the signal.
+*
+* Use when you need to ensure a signal exists and is subscribed to.
+*
+* @internal
+*/
 export declare function entangleSignal<T extends object>(signals: SignalStore, obj: T, key: string | symbol, initialValue: unknown): WarpDriveSignal;
 /**
- * define an enumerable signal property.
- *
- * Akin to Object.defineProperty.
- *
- * The signal will be lazily created when accessed and scoped to the
- * instance of the object.
- *
- * @internal
- */
+* define an enumerable signal property.
+*
+* Akin to Object.defineProperty.
+*
+* The signal will be lazily created when accessed and scoped to the
+* instance of the object.
+*
+* @internal
+*/
 export declare function defineSignal<T extends object>(obj: T, key: string, v?: unknown): void;
 /**
- * Define a non-enumerable signal property.
- *
- * @internal
- */
+* Define a non-enumerable signal property.
+*
+* @internal
+*/
 export declare function defineNonEnumerableSignal<T extends object>(obj: T, key: string, v?: unknown): void;
-export declare function memoized<T extends object, K extends keyof T & string>(target: T, key: K, descriptor: PropertyDescriptor): PropertyDescriptor;
-export declare function gate<T extends object, K extends keyof T & string>(_target: T, key: K, desc: PropertyDescriptor): PropertyDescriptor;
+export declare function memoized<
+	T extends object,
+	K extends keyof T & string
+>(target: T, key: K, descriptor: PropertyDescriptor): PropertyDescriptor;
+export declare function gate<
+	T extends object,
+	K extends keyof T & string
+>(_target: T, key: K, desc: PropertyDescriptor): PropertyDescriptor;
 export declare function defineGate<T extends object>(obj: T, key: string, desc: PropertyDescriptor): void;
-//# sourceMappingURL=signal.d.ts.map

package/declarations/store/-private/new-core-tmp/request-state.d.ts

@@ -1,255 +1,277 @@
-import type { Future } from '../../../request.ts';
-import type { ImmutableRequestInfo, ResponseInfo, StructuredErrorDocument } from '../../../types/request.ts';
-import type { PendingPromise, RejectedPromise, ResolvedPromise } from './promise-state.ts';
+import type { Future } from "../../../request.js";
+import type { ImmutableRequestInfo, ResponseInfo, StructuredErrorDocument } from "../../../types/request.js";
+import type { PendingPromise, RejectedPromise, ResolvedPromise } from "./promise-state.js";
 /**
- * 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.
- *
- */
+* 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.
+*
+*/
 export declare class RequestLoadingState {
-    _sizeHint: number;
-    _bytesLoaded: number;
-    _startTime: number;
-    _endTime: number;
-    _lastPacketTime: number;
-    _isPending: boolean;
-    _isStarted: boolean;
-    _isComplete: boolean;
-    _isCancelled: boolean;
-    _isErrored: boolean;
-    _error: Error | null;
-    _stream: TransformStream | null;
-    _future: Future<unknown>;
-    _triggered: boolean;
-    _trigger(): void;
-    promise: Promise<void> | null;
-    get isPending(): boolean;
-    get sizeHint(): number;
-    get stream(): ReadableStream | null;
-    get isStarted(): boolean;
-    get bytesLoaded(): number;
-    get startTime(): number;
-    get endTime(): number;
-    get lastPacketTime(): number;
-    get isComplete(): boolean;
-    get isCancelled(): boolean;
-    get isErrored(): boolean;
-    get error(): Error | null;
-    get elapsedTime(): number;
-    get completedRatio(): number;
-    get remainingRatio(): number;
-    get duration(): number;
-    get speed(): number;
-    constructor(future: Future<unknown>);
-    abort: () => void;
+	private _sizeHint;
+	private _bytesLoaded;
+	private _startTime;
+	private _endTime;
+	private _lastPacketTime;
+	private _isPending;
+	private _isStarted;
+	private _isComplete;
+	private _isCancelled;
+	private _isErrored;
+	private _error;
+	private _stream;
+	private _future;
+	private _triggered;
+	private _trigger;
+	promise: Promise<void> | null;
+	get isPending(): boolean;
+	get sizeHint(): number;
+	get stream(): ReadableStream | null;
+	get isStarted(): boolean;
+	get bytesLoaded(): number;
+	get startTime(): number;
+	get endTime(): number;
+	get lastPacketTime(): number;
+	get isComplete(): boolean;
+	get isCancelled(): boolean;
+	get isErrored(): boolean;
+	get error(): Error | null;
+	get elapsedTime(): number;
+	get completedRatio(): number;
+	get remainingRatio(): number;
+	get duration(): number;
+	get speed(): number;
+	constructor(future: Future<unknown>);
+	abort: () => void;
 }
 /**
- * The state of a request in the "pending"
- * state. This is the default initial state.
- *
- * Extends the {@link PendingPromise} interface.
- *
- */
+* The state of a request in the "pending"
+* state. This is the default initial state.
+*
+* Extends the {@link PendingPromise} interface.
+*
+*/
 export interface PendingRequest extends PendingPromise {
-    /**
-     * Whether the request is cancelled.
-     *
-     */
-    isCancelled: false;
-    loadingState: RequestLoadingState;
-    request: null;
-    response: null;
+	/**
+	* Whether the request is cancelled.
+	*
+	*/
+	isCancelled: false;
+	loadingState: RequestLoadingState;
+	request: null;
+	response: null;
 }
 /**
- * The state of a request in the "fulfilled" state.
- * This is the state of a request that has resolved
- * successfully.
- *
- * Extends the {@link ResolvedPromise} interface.
- *
- */
-export interface ResolvedRequest<RT, T> extends ResolvedPromise<RT> {
-    /**
-     * Whether the request is cancelled.
-     *
-     */
-    isCancelled: false;
-    loadingState: RequestLoadingState;
-    request: ImmutableRequestInfo<RT, T> | null;
-    response: Response | ResponseInfo | null;
+* The state of a request in the "fulfilled" state.
+* This is the state of a request that has resolved
+* successfully.
+*
+* Extends the {@link ResolvedPromise} interface.
+*
+*/
+export interface ResolvedRequest<
+	RT,
+	T
+> extends ResolvedPromise<RT> {
+	/**
+	* Whether the request is cancelled.
+	*
+	*/
+	isCancelled: false;
+	loadingState: RequestLoadingState;
+	request: ImmutableRequestInfo<RT, T> | null;
+	response: Response | ResponseInfo | null;
 }
 /**
- * The state of a request in the "rejected" state.
- * This is the state of a request that has rejected
- * with an error.
- *
- * Extends the {@link RejectedPromise} interface.
- *
- */
-export interface RejectedRequest<RT, T, E extends StructuredErrorDocument = StructuredErrorDocument> extends RejectedPromise<E> {
-    /**
-     * Whether the request is cancelled.
-     *
-     */
-    isCancelled: false;
-    loadingState: RequestLoadingState;
-    request: ImmutableRequestInfo<RT, T> | null;
-    response: Response | ResponseInfo | null;
+* The state of a request in the "rejected" state.
+* This is the state of a request that has rejected
+* with an error.
+*
+* Extends the {@link RejectedPromise} interface.
+*
+*/
+export interface RejectedRequest<
+	RT,
+	T,
+	E extends StructuredErrorDocument = StructuredErrorDocument
+> extends RejectedPromise<E> {
+	/**
+	* Whether the request is cancelled.
+	*
+	*/
+	isCancelled: false;
+	loadingState: RequestLoadingState;
+	request: ImmutableRequestInfo<RT, T> | null;
+	response: Response | ResponseInfo | null;
 }
 /**
- * The state of a request in the "cancelled" state.
- * This is the state of a promise that has been
- * cancelled.
- *
- */
-export interface CancelledRequest<RT, T, E extends StructuredErrorDocument = StructuredErrorDocument> {
-    /**
-     * The status of the request.
-     *
-     */
-    status: 'cancelled';
-    /**
-     * Whether the request is pending.
-     *
-     */
-    isPending: false;
-    /**
-     * Whether the request is pending.
-     *
-     */
-    isLoading: false;
-    /**
-     * Whether the request has resolved
-     * successfully.
-     *
-     */
-    isSuccess: false;
-    /**
-     * Whether the request has rejected
-     * with an error.
-     *
-     */
-    isError: true;
-    /**
-     * Once the request has resolved, this will
-     * be the value the request resolved to.
-     *
-     */
-    value: null;
-    /**
-     * Once the request has resolved, this will
-     * be the value the request resolved to.
-     *
-     * @deprecated use `value` instead
-     */
-    result: null;
-    /**
-     * Once the request has rejected, this will
-     * be the error the request rejected with.
-     *
-     *
-     * @deprecated use `reason` instead
-     */
-    error: E;
-    /**
-     * Once the request has rejected, this will
-     * be the error the request rejected with.
-     *
-     */
-    reason: E;
-    /**
-     * Whether the request is cancelled.
-     *
-     */
-    isCancelled: true;
-    loadingState: RequestLoadingState;
-    request: ImmutableRequestInfo<RT, T> | null;
-    response: Response | ResponseInfo | null;
+* The state of a request in the "cancelled" state.
+* This is the state of a promise that has been
+* cancelled.
+*
+*/
+export interface CancelledRequest<
+	RT,
+	T,
+	E extends StructuredErrorDocument = StructuredErrorDocument
+> {
+	/**
+	* The status of the request.
+	*
+	*/
+	status: "cancelled";
+	/**
+	* Whether the request is pending.
+	*
+	*/
+	isPending: false;
+	/**
+	* Whether the request is pending.
+	*
+	*/
+	isLoading: false;
+	/**
+	* Whether the request has resolved
+	* successfully.
+	*
+	*/
+	isSuccess: false;
+	/**
+	* Whether the request has rejected
+	* with an error.
+	*
+	*/
+	isError: true;
+	/**
+	* Once the request has resolved, this will
+	* be the value the request resolved to.
+	*
+	*/
+	value: null;
+	/**
+	* Once the request has resolved, this will
+	* be the value the request resolved to.
+	*
+	* @deprecated use `value` instead
+	*/
+	result: null;
+	/**
+	* Once the request has rejected, this will
+	* be the error the request rejected with.
+	*
+	*
+	* @deprecated use `reason` instead
+	*/
+	error: E;
+	/**
+	* Once the request has rejected, this will
+	* be the error the request rejected with.
+	*
+	*/
+	reason: E;
+	/**
+	* Whether the request is cancelled.
+	*
+	*/
+	isCancelled: true;
+	loadingState: RequestLoadingState;
+	request: ImmutableRequestInfo<RT, T> | null;
+	response: Response | ResponseInfo | null;
 }
 /**
- * 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`.
- *
- * See also:
- * - {@link PendingRequest}
- * - {@link ResolvedRequest}
- * - {@link RejectedRequest}
- * - {@link CancelledRequest}
- *
- */
-export type RequestCacheRequestState<RT = unknown, T = unknown, E extends StructuredErrorDocument = StructuredErrorDocument> = PendingRequest | ResolvedRequest<RT, T> | RejectedRequest<RT, T, E> | CancelledRequest<RT, T, E>;
-export declare function createRequestState<RT, T, E>(future: Future<RT>): Readonly<RequestCacheRequestState<RT, T, StructuredErrorDocument<E>>>;
+* 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`.
+*
+* See also:
+* - {@link PendingRequest}
+* - {@link ResolvedRequest}
+* - {@link RejectedRequest}
+* - {@link CancelledRequest}
+*
+*/
+export type RequestCacheRequestState<
+	RT = unknown,
+	T = unknown,
+	E extends StructuredErrorDocument = StructuredErrorDocument
+> = PendingRequest | ResolvedRequest<RT, T> | RejectedRequest<RT, T, E> | CancelledRequest<RT, T, E>;
+export declare function createRequestState<
+	RT,
+	T,
+	E
+>(future: Future<RT>): Readonly<RequestCacheRequestState<RT, T, StructuredErrorDocument<E>>>;
 /**
- * `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.
- *
- */
-export declare function getRequestState<RT, T, E>(future: Future<RT>): Readonly<RequestCacheRequestState<RT, T, StructuredErrorDocument<E>>>;
-//# sourceMappingURL=request-state.d.ts.map
+* `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.
+*
+*/
+export declare function getRequestState<
+	RT,
+	T,
+	E
+>(future: Future<RT>): Readonly<RequestCacheRequestState<RT, T, StructuredErrorDocument<E>>>;