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

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

@@ -1,35 +0,0 @@
-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
-*/
-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
-*/
-export declare function defineSignal<T extends object>(obj: T, key: string, v?: unknown): void;
-/**
-* 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 defineGate<T extends object>(obj: T, key: string, desc: PropertyDescriptor): void;

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

@@ -1,277 +0,0 @@
-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.
-*
-*/
-export declare class RequestLoadingState {
-	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.
-*
-*/
-export interface PendingRequest extends PendingPromise {
-	/**
-	* 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 "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;
-}
-/**
-* 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>>>;

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

@@ -1,261 +0,0 @@
-import type { RequestManager, Store, StoreRequestInput } from "../../../index.js";
-import type { Future } from "../../../request.js";
-import type { StructuredErrorDocument } from "../../../types/request.js";
-import type { RequestState } from "../../-private.js";
-export declare const DISPOSE: "(symbol) dispose";
-interface ErrorFeatures {
-	isHidden: boolean;
-	isOnline: boolean;
-	retry: () => Promise<void>;
-}
-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>;
-};
-// eslint-disable-next-line @typescript-eslint/no-unused-vars
-export interface SubscriptionArgs<
-	RT,
-	T,
-	E
-> {
-	/**
-	* 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 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";
-}
-// eslint-disable-next-line @typescript-eslint/no-unused-vars
-export interface RequestSubscription<
-	RT,
-	T,
-	E
-> {
-	/**
-	* The method to call when the component this subscription is attached to
-	* unmounts.
-	*/
-	[DISPOSE](): void;
-}
-/**
-* A reactive class
-*
-* @hideconstructor
-*/
-export declare class RequestSubscription<
-	RT,
-	T,
-	E
-> {
-	/**
-	* Whether the browser reports that the network is online.
-	*/
-	isOnline: boolean;
-	/**
-	* Whether the browser reports that the tab is hidden.
-	*/
-	isHidden: boolean;
-	/**
-	* Whether the component is currently refreshing the request.
-	*/
-	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
-	*/
-	private _localRequest;
-	/**
-	* 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
-	*/
-	private _latestRequest;
-	/**
-	* The time at which the network was reported as offline.
-	*
-	* @internal
-	*/
-	private _unavailableStart;
-	/** @internal */
-	private _intervalStart;
-	/** @internal */
-	private _nextInterval;
-	/** @internal */
-	private _invalidated;
-	/** @internal */
-	private _isUpdating;
-	/** @internal */
-	private isDestroyed;
-	/**
-	* The event listener for network status changes,
-	* cached to use the reference for removal.
-	*
-	* @internal
-	*/
-	private _onlineChanged;
-	/**
-	* The event listener for visibility status changes,
-	* cached to use the reference for removal.
-	*
-	* @internal
-	*/
-	private _backgroundChanged;
-	/**
-	* The last request passed as an arg to the component,
-	* cached for comparison.
-	*
-	* @internal
-	*/
-	private _originalRequest;
-	/**
-	* The last query passed as an arg to the component,
-	* cached for comparison.
-	*
-	* @internal
-	*/
-	private _originalQuery;
-	/** @internal */
-	private _subscription;
-	/** @internal */
-	private _subscribedTo;
-	/** @internal */
-	private _args;
-	/** @internal */
-	store: Store | RequestManager;
-	constructor(store: Store | RequestManager, args: SubscriptionArgs<RT, T, E>);
-	/**
-	* @internal
-	*/
-	private _beginPolling;
-	get isIdle(): boolean;
-	get autorefreshTypes(): Set<AutorefreshBehaviorType>;
-	// 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.
-	private _scheduleInterval;
-	private _clearInterval;
-	/**
-	* @internal
-	*/
-	private _updateSubscriptions;
-	/**
-	* @internal
-	*/
-	private _removeSubscriptions;
-	/**
-	* Install the event listeners for network and visibility changes.
-	* This is only done in browser environments with a global `window`.
-	*
-	* @internal
-	*/
-	private _installListeners;
-	/**
-	* 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
-	*/
-	private _maybeUpdate;
-	/**
-	* Retry the request, reloading it from the server.
-	*/
-	retry: () => Promise<void>;
-	/**
-	* Refresh the request, updating it in the background.
-	*/
-	refresh: () => Promise<void>;
-	/**
-	* features to yield to the error slot of a component
-	*/
-	get errorFeatures(): ErrorFeatures;
-	/**
-	* features to yield to the content slot of a component
-	*/
-	get contentFeatures(): ContentFeatures<RT>;
-	/**
-	* @internal
-	*/
-	get _request(): Future<RT>;
-	get request(): Future<RT>;
-	get reqState(): RequestState<RT, T, StructuredErrorDocument<E>>;
-	get result(): RT;
-}
-export declare function createRequestSubscription<
-	RT,
-	T,
-	E
->(store: Store | RequestManager, args: SubscriptionArgs<RT, T, E>): RequestSubscription<RT, T, E>;
-export {};