@warp-drive/core 5.8.0-alpha.37 → 5.8.0-alpha.40

package/dist/unpkg/prod-deprecated/declarations/store/-private/new-core-tmp/request-state.d.ts

@@ -1,372 +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.
-*
-* @hideconstructor
-*/
-export declare class RequestLoadingState {
-	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> extends ResolvedPromise<RT> {
-	/**
-	* Retries the request with high (blocking) priority. This is the
-	* same as having passed `cacheOptions.reload = true` on the original
-	* request.
-	*
-	* This will not change the existing request's state. To subscribe
-	* to the new request's state, use `getRequestState` on the returned
-	* {@link Future}.
-	*
-	* ```ts
-	* const future = state.reload();
-	* const state = getRequestState(future);
-	* ```
-	*
-	* It is safe to pass this around as an "action" or "event" handler
-	* as its context is bound.
-	*/
-	reload(): Future<RT>;
-	/**
-	* Retries the request with low (non-blocking) priority. This is the
-	* same as having passed `cacheOptions.backgroundReload = true` on the original
-	* request.
-	*
-	* This will not change the existing request's state. To subscribe
-	* to the new request's state, use `getRequestState` on the returned
-	* {@link Future}.
-	*
-	* ```ts
-	* const future = state.reload();
-	* const state = getRequestState(future);
-	* ```
-	*
-	* It is safe to pass this around as an "action" or "event" handler
-	* as its context is bound.
-	*/
-	refresh(usePolicy?: boolean): Future<RT>;
-	/**
-	* Whether the request is cancelled.
-	*
-	*/
-	isCancelled: false;
-	/**
-	* A lazily created {@link RequestLoadingState} instance
-	* which provides a number of reactive properties that can be used
-	* to build UIs that respond to the progress of a request.
-	*/
-	loadingState: RequestLoadingState;
-	request: ImmutableRequestInfo<RT> | 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,
-	E extends StructuredErrorDocument = StructuredErrorDocument
-> extends RejectedPromise<E> {
-	/**
-	* Retries the request with high (blocking) priority. This is the
-	* same as having passed `cacheOptions.reload = true` on the original
-	* request.
-	*
-	* This will not change the existing request's state. To subscribe
-	* to the new request's state, use `getRequestState` on the returned
-	* {@link Future}.
-	*
-	* ```ts
-	* const future = state.reload();
-	* const state = getRequestState(future);
-	* ```
-	*
-	* It is safe to pass this around as an "action" or "event" handler
-	* as its context is bound.
-	*/
-	reload(): Future<RT>;
-	/**
-	* Retries the request with low (non-blocking) priority. This is the
-	* same as having passed `cacheOptions.backgroundReload = true` on the original
-	* request.
-	*
-	* This will not change the existing request's state. To subscribe
-	* to the new request's state, use `getRequestState` on the returned
-	* {@link Future}.
-	*
-	* ```ts
-	* const future = state.reload();
-	* const state = getRequestState(future);
-	* ```
-	*
-	* It is safe to pass this around as an "action" or "event" handler
-	* as its context is bound.
-	*/
-	refresh(usePolicy?: boolean): Future<RT>;
-	/**
-	* Whether the request is cancelled.
-	*
-	*/
-	isCancelled: false;
-	loadingState: RequestLoadingState;
-	request: ImmutableRequestInfo<RT> | 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,
-	E extends StructuredErrorDocument = StructuredErrorDocument
-> {
-	/**
-	* Retries the request with high (blocking) priority. This is the
-	* same as having passed `cacheOptions.reload = true` on the original
-	* request.
-	*
-	* This will not change the existing request's state. To subscribe
-	* to the new request's state, use `getRequestState` on the returned
-	* {@link Future}.
-	*
-	* ```ts
-	* const future = state.reload();
-	* const state = getRequestState(future);
-	* ```
-	*
-	* It is safe to pass this around as an "action" or "event" handler
-	* as its context is bound.
-	*/
-	reload(): Future<RT>;
-	/**
-	* Retries the request with low (non-blocking) priority. This is the
-	* same as having passed `cacheOptions.backgroundReload = true` on the original
-	* request.
-	*
-	* This will not change the existing request's state. To subscribe
-	* to the new request's state, use `getRequestState` on the returned
-	* {@link Future}.
-	*
-	* ```ts
-	* const future = state.reload();
-	* const state = getRequestState(future);
-	* ```
-	*
-	* It is safe to pass this around as an "action" or "event" handler
-	* as its context is bound.
-	*/
-	refresh(usePolicy?: boolean): Future<RT>;
-	/**
-	* 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> | null;
-	response: Response | ResponseInfo | null;
-}
-export interface PrivateRequestState {
-	_loadingState?: RequestLoadingState;
-	_request: Future<unknown>;
-}
-/**
-* RequestState extends the concept of {@link PromiseState} to provide a reactive
-* wrapper for a request {@link 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 {@link Promise} and a Future is that Futures provide
-* access to a {@link ReadableStream | stream} of their content, the {@link RequestKey} of the request (if any)
-* as well as the ability to attempt to {@link Future.abort | abort} the request.
-*
-* ```ts
-* interface Future<T> extends Promise<T>> {
-*   getStream(): Promise<ReadableStream>;
-*   abort(): void;
-*   lid: RequestKey | null;
-* }
-* ```
-*
-* These additional APIs allow us to craft even richer state experiences.
-*
-* To get the state of a request, use {@link getRequestState}.
-*
-* See also:
-* - {@link PendingRequest}
-* - {@link ResolvedRequest}
-* - {@link RejectedRequest}
-* - {@link CancelledRequest}
-*
-*/
-export type RequestCacheRequestState<
-	RT = unknown,
-	E extends StructuredErrorDocument = StructuredErrorDocument
-> = PendingRequest | ResolvedRequest<RT> | RejectedRequest<RT, E> | CancelledRequest<RT, E>;
-export declare function createRequestState<
-	RT,
-	E
->(future: Future<RT>): Readonly<RequestCacheRequestState<RT, 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 number of additional capabilities for requests *beyond* what
-* `RequestState` provides.
-*
-*/
-export declare function getRequestState<
-	RT,
-	E
->(future: Future<RT>): Readonly<RequestCacheRequestState<RT, StructuredErrorDocument<E>>>;

package/dist/unpkg/prod-deprecated/declarations/store/-private/new-core-tmp/request-subscription.d.ts

@@ -1,177 +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";
-export type AutorefreshBehaviorType = "online" | "interval" | "invalid";
-export type AutorefreshBehaviorCombos = boolean | AutorefreshBehaviorType | `${AutorefreshBehaviorType},${AutorefreshBehaviorType}` | `${AutorefreshBehaviorType},${AutorefreshBehaviorType},${AutorefreshBehaviorType}`;
-/**
-* Utilities to assist in recovering from the error.
-*/
-export interface RecoveryFeatures {
-	isOnline: boolean;
-	isHidden: boolean;
-	retry: () => Promise<void>;
-}
-/** @deprecated use {@link RecoveryFeatures} */
-export type ErrorFeatures = RecoveryFeatures;
-/**
-* Utilities for keeping the request fresh
-*/
-export interface ContentFeatures<RT> {
-	isOnline: boolean;
-	isHidden: boolean;
-	isRefreshing: boolean;
-	refresh: () => Promise<void>;
-	reload: () => Promise<void>;
-	abort?: () => void;
-	latestRequest?: Future<RT>;
-}
-export interface RequestArgs<
-	RT,
-	E
-> extends SubscriptionArgs<RT, E> {
-	subscription?: RequestSubscription<RT, E>;
-	/**
-	* 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 | RequestManager;
-}
-export interface SubscriptionArgs<
-	RT,
-	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> | undefined | null;
-	/**
-	* 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> | undefined | null;
-	/**
-	* 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";
-}
-export interface RequestComponentArgs<
-	RT,
-	E
-> extends SubscriptionArgs<RT, E> {
-	/**
-	* 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 | RequestManager;
-}
-export interface RequestSubscription<
-	RT,
-	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,
-	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 Store this subscription subscribes to or the RequestManager
-	* which issues this request.
-	*/
-	store: Store | RequestManager;
-	constructor(store: Store | RequestManager, args: SubscriptionArgs<RT, E>);
-	get isIdle(): boolean;
-	get autorefreshTypes(): Set<AutorefreshBehaviorType>;
-	/**
-	* 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(): RecoveryFeatures;
-	/**
-	* features to yield to the content slot of a component
-	*/
-	get contentFeatures(): ContentFeatures<RT>;
-	get request(): Future<RT>;
-	get reqState(): RequestState<RT, StructuredErrorDocument<E>>;
-	get result(): RT;
-}
-export declare function createRequestSubscription<
-	RT,
-	E
->(store: Store | RequestManager, args: SubscriptionArgs<RT, E>): RequestSubscription<RT, E>;

package/dist/unpkg/prod-deprecated/declarations/store/-private/record-arrays/-utils.d.ts

@@ -1,80 +0,0 @@
-import type { BaseFinderOptions } from "../../../types.js";
-import type { LocalRelationshipOperation } from "../../../types/graph.js";
-import type { ResourceKey } from "../../../types/identifier.js";
-import type { Store } from "../store-service.js";
-import type { NativeProxy } from "./native-proxy-type-fix.js";
-import type { ReactiveResourceArray } from "./resource-array.js";
-/**
-* LegacyArrays have the capability of updating via `array.update()`
-* and saving each contained record individually via `array.save()`
-*/
-export interface LegacyArray<T = unknown> extends ReactiveResourceArray<T> {
-	/**
-	The flag to signal a `RecordArray` is currently loading data.
-	Example
-	```javascript
-	let people = store.peekAll('person');
-	people.isUpdating; // false
-	people.update();
-	people.isUpdating; // true
-	```
-	*/
-	isUpdating: boolean;
-	/**
-	Used to get the latest version of all of the records in this array
-	from the adapter.
-	
-	Example
-	
-	```javascript
-	let people = store.peekAll('person');
-	people.isUpdating; // false
-	
-	people.update().then(function() {
-	people.isUpdating; // false
-	});
-	
-	people.isUpdating; // true
-	```
-	
-	@public
-	*/
-	update(this: LegacyArray<T>): Promise<LegacyArray<T>>;
-	/**
-	Saves all of the records in the `RecordArray`.
-	
-	Example
-	
-	```js
-	let messages = store.peekAll('message');
-	messages.forEach(function(message) {
-	message.hasBeenSeen = true;
-	});
-	messages.save();
-	```
-	
-	@public
-	*/
-	save(this: LegacyArray<T>): Promise<LegacyArray<T>>;
-}
-export declare function upgradeThis(obj: unknown): asserts obj is LegacyArray;
-export declare function update(this: ReactiveResourceArray): Promise<ReactiveResourceArray>;
-export declare function save(this: ReactiveResourceArray): Promise<ReactiveResourceArray>;
-export type KeyType = string | symbol | number;
-export declare function isArrayGetter<T>(prop: KeyType): prop is keyof Array<T>;
-export declare function isArraySetter<T>(prop: KeyType): prop is keyof Array<T>;
-export declare function convertToInt(prop: KeyType): number | null;
-export type ForEachCB<T> = (record: T, index: number, context: typeof NativeProxy<ResourceKey[], T[]>) => void;
-export declare function safeForEach<T>(instance: typeof NativeProxy<ResourceKey[], T[]>, arr: ResourceKey[], store: Store, callback: ForEachCB<T>, target: unknown): typeof NativeProxy<ResourceKey[], T[]>;
-type PromiseTo<T> = Omit<Promise<T>, typeof Symbol.toStringTag>;
-type PromiseManyArray<T> = {
-	length: number;
-	content: ReactiveResourceArray<T> | null;
-	promise: Promise<ReactiveResourceArray<T>> | null;
-} & PromiseTo<ReactiveResourceArray<T>>;
-export interface MinimumManager {
-	_syncArray(array: ReactiveResourceArray): void;
-	mutate?(mutation: LocalRelationshipOperation): void;
-	reloadHasMany?<T>(key: string, options?: BaseFinderOptions): Promise<ReactiveResourceArray> | PromiseManyArray<T>;
-}
-export {};

package/dist/unpkg/prod-deprecated/declarations/store/-private/record-arrays/legacy-live-array.d.ts

@@ -1,81 +0,0 @@
-import type { ResourceKey } from "../../../types/identifier.js";
-import type { TypeFromInstanceOrString } from "../../../types/record.js";
-import type { Store } from "../store-service.js";
-import type { LegacyArray, MinimumManager } from "./-utils.js";
-/**
-* LiveArrays contain all the known records for a given `ResourceType`.
-*
-* ### Basic Example
-*
-* For instance, if an application were to have a `'user'` type:
-*
-* ```ts
-* const usersLiveArray = store.peekAll('user');
-* ```
-*
-* ---
-*
-*  
-*
-* ### LiveArrays are Arrays
-*
-* LiveArrays have all array APIs, and will report `true`
-* for both `liveArray instanceof Array` and `Array.isArray(liveArray)`
-*
-* ---
-*
-*  
-*
-* ### Reactive
-*
-* The array is "live" as it will reactively update any time new
-* users are added to the store's cache.
-*
-* There is only one LiveArray instance per ResourceType, and it
-* can be accessed either via {@link Store.peekAll} or {@link Store.findAll}
-*
-* ```ts
-* const users = await store.findAll('user');
-* const peekedUsers = store.peekAll('user');
-* peekedUsers === users; // true
-* ```
-*
-* ---
-*
-*  
-*
-* ### New Records
-*
-* Records in the `"new"` state (created locally on the client
-* but not yet saved) appear in LiveArrays if they are in LegacyMode.
-*
-* PolarisMode records in the `"new"` state do not appear in LiveArrays.
-*
-* ---
-*
-*  
-*
-* ### Polymorphism
-*
-* LiveArrays are not polymorphic. If your application has an abstract
-* type "car" with concrete types "ferrari" and "bmw", then "ferrari"
-* and "bmw" will have populated LiveArrays, but the LiveArray for "car"
-* would be empty.
-*
-* @legacy we recommend againt using LiveArrays. Use {@link Store.request} instead
-*/
-export interface LegacyLiveArray<T = unknown> extends LegacyArray<T> {
-	isLoaded: boolean;
-	modelName: TypeFromInstanceOrString<T>;
-}
-/**
-* The options for {@link createLegacyLiveArray}
-*
-* @private
-*/
-export interface LegacyLiveArrayCreateOptions {
-	store: Store;
-	manager: MinimumManager;
-	source: ResourceKey[];
-	type: string;
-}