@warp-drive-mirror/core 5.9.0-alpha.2 → 5.9.0-alpha.21

package/declarations/reactive/-private/schema.d.ts

@@ -1,326 +0,0 @@
-import type { SchemaService as SchemaServiceInterface } from "../../types.js";
-import type { ResourceKey } from "../../types/identifier.js";
-import type { ObjectValue, Value } from "../../types/json/raw.js";
-import type { Derivation, HashFn } from "../../types/schema/concepts.js";
-import { type ArrayField, type CacheableFieldSchema, type DerivedField, type FieldSchema, type GenericField, type HashField, type IdentityField, type LegacyAttributeField, type LegacyRelationshipField, type ObjectField, type ObjectSchema, type PolarisResourceSchema, type ResourceSchema, type Trait } from "../../types/schema/fields.js";
-import { Type } from "../../types/symbols.js";
-import type { WithPartial } from "../../types/utils.js";
-import type { ReactiveResource } from "./record.js";
-/**
-* Extensions allow providing non-schema driven behaviors to
-* ReactiveResources, ReactiveArrays, and ReactiveObjects.
-*
-* This should only be used for temporary migration purposes
-* to the new schema system when migrating from either Model
-* or ModelFragments.
-*/
-export interface CAUTION_MEGA_DANGER_ZONE_Extension {
-	/**
-	* Whether this extension extends the behaviors of objects
-	* (both ReactiveObjects and ReactiveResources) or of arrays.
-	*/
-	kind: "object" | "array";
-	/**
-	* The name of the extension, to be used when specifying
-	* either `objectExtensions` or `arrayExtensions` on the
-	* field, ResourceSchema or ObjectSchema
-	*/
-	name: string;
-	/**
-	* An object with iterable keys whose values are the getters
-	* or methods to expose on the object or array.
-	*
-	* or
-	*
-	* A constructable such as a Function or Class whose prototype
-	* will be iterated with getOwnPropertyNames.
-	*
-	* Examples:
-	*
-	* **An Object with methods**
-	*
-	* ```ts
-	* store.schema.CAUTION_MEGA_DANGER_ZONE_registerExtension({
-	*    kind: 'object',
-	*    name: 'do-thing-1',
-	*    features: {
-	*      doThingOne(this: { street: string }) {
-	*        return `do-thing-1:${this.street}`;
-	*      },
-	*      doThingTwo(this: { street: string }) {
-	*        return `do-thing-1:${this.street}`;
-	*      },
-	*    },
-	*  });
-	* ```
-	*
-	* **A class with getters, methods and decorated fields**
-	*
-	* ```ts
-	* class Features {
-	*   sayHello() {
-	*     return 'hello!';
-	*   }
-	*
-	*   @tracked trackedField = 'initial tracked value';
-	*
-	*   get realName() {
-	*     const self = this as unknown as { name: string };
-	*     return self.name;
-	*   }
-	*   set realName(v: string) {
-	*     const self = this as unknown as { name: string };
-	*     self.name = v;
-	*   }
-	*
-	*   get greeting() {
-	*     const self = this as unknown as { name: string };
-	*     return `hello ${self.name}!`;
-	*   }
-	*
-	*   @computed('name')
-	*   get salutation() {
-	*     const self = this as unknown as { name: string };
-	*     return `salutations ${self.name}!`;
-	*   }
-	*
-	*   @cached
-	*   get helloThere() {
-	*     const self = this as unknown as { name: string };
-	*     return `Well Hello There ${self.name}!`;
-	*   }
-	* }
-	*
-	* // non-decorated fields dont appear on class prototypes as they are instance only
-	* // @ts-expect-error
-	* Features.prototype.untrackedField = 'initial untracked value';
-	*
-	* store.schema.CAUTION_MEGA_DANGER_ZONE_registerExtension({
-	*   kind: 'object',
-	*   name: 'my-ext',
-	*   features: Features,
-	* });
-	* ```
-	*
-	*/
-	features: Record<string | symbol, unknown> | Function;
-}
-export type ExtensionDef = {
-	kind: "method";
-	fn: Function;
-} | {
-	kind: "readonly-value";
-	value: unknown;
-} | {
-	kind: "mutable-value";
-	value: unknown;
-} | {
-	kind: "readonly-field";
-	get: () => unknown;
-} | {
-	kind: "mutable-field";
-	get: () => unknown;
-	set: (value: unknown) => void;
-} | {
-	kind: "writeonly-field";
-	set: (value: unknown) => void;
-};
-export interface ProcessedExtension {
-	kind: "object" | "array";
-	name: string;
-	features: Map<string | symbol, ExtensionDef>;
-}
-export interface ExtensibleField {
-	kind: "schema-object" | "schema-array" | "array" | "object" | "hasMany";
-	options?: {
-		objectExtensions?: string[];
-		arrayExtensions?: string[];
-	};
-}
-/**
-* Utility for constructing a ResourceSchema with the recommended
-* fields for the PolarisMode experience.
-*
-* Using this requires registering the PolarisMode derivations
-*
-* ```ts
-* import { registerDerivations } from '@warp-drive-mirror/schema-record';
-*
-* registerDerivations(schema);
-* ```
-*
-* @public
-* @param schema
-* @return {PolarisResourceSchema}
-*/
-export declare function withDefaults(schema: WithPartial<PolarisResourceSchema, "identity">): PolarisResourceSchema;
-interface FromIdentityDerivation {
-	(record: ReactiveResource, options: {
-		key: "lid";
-	} | {
-		key: "type";
-	}, key: string): string;
-	(record: ReactiveResource, options: {
-		key: "id";
-	}, key: string): string | null;
-	(record: ReactiveResource, options: {
-		key: "^";
-	}, key: string): ResourceKey;
-	(record: ReactiveResource, options: null, key: string): asserts options;
-	(record: ReactiveResource, options: {
-		key: "id" | "lid" | "type" | "^";
-	} | null, key: string): ResourceKey | string | null;
-	[Type]: "@identity";
-}
-/**
-* A derivation that computes its value from the
-* record's identity.
-*
-* It can be used via a derived field definition like:
-*
-* ```ts
-* {
-*   kind: 'derived',
-*   name: 'id',
-*   type: '@identity',
-*   options: { key: 'id' }
-* }
-* ```
-*
-* Valid keys are `'id'`, `'lid'`, `'type'`, and `'^'`.
-*
-* `^` returns the entire identifier object.
-*
-* @public
-*/
-export declare const fromIdentity: FromIdentityDerivation;
-/**
-* Registers the default derivations for records that want
-* to use the PolarisMode defaults provided by
-*
-* ```ts
-* import { withDefaults } from '@warp-drive-mirror/schema-record';
-* ```
-*
-* @public
-*/
-export declare function registerDerivations(schema: SchemaServiceInterface): void;
-interface InternalSchema {
-	original: ResourceSchema | ObjectSchema;
-	finalized: boolean;
-	traits: Set<string>;
-	fields: Map<string, FieldSchema>;
-	cacheFields: Map<string, Exclude<CacheableFieldSchema, IdentityField>>;
-	attributes: Record<string, LegacyAttributeField>;
-	relationships: Record<string, LegacyRelationshipField>;
-}
-export type Transformation<
-	T extends Value = Value,
-	PT = unknown
-> = {
-	serialize(value: PT, options: Record<string, unknown> | null, record: ReactiveResource): T;
-	hydrate(value: T | undefined, options: Record<string, unknown> | null, record: ReactiveResource): PT;
-	defaultValue?(options: Record<string, unknown> | null, identifier: ResourceKey): T;
-	[Type]: string;
-};
-export interface SchemaService {
-	doesTypeExist(type: string): boolean;
-	attributesDefinitionFor(identifier: {
-		type: string;
-	}): InternalSchema["attributes"];
-	relationshipsDefinitionFor(identifier: {
-		type: string;
-	}): InternalSchema["relationships"];
-}
-/**
-* A SchemaService designed to work with dynamically registered schemas.
-*
-* @public
-*/
-export declare class SchemaService implements SchemaServiceInterface {
-	constructor();
-	resourceTypes(): Readonly<string[]>;
-	hasTrait(type: string): boolean;
-	resourceHasTrait(resource: ResourceKey | {
-		type: string;
-	}, trait: string): boolean;
-	transformation(field: GenericField | ObjectField | ArrayField | {
-		type: string;
-	}): Transformation;
-	derivation(field: DerivedField | {
-		type: string;
-	}): Derivation;
-	hashFn(field: HashField | {
-		type: string;
-	}): HashFn;
-	resource(resource: ResourceKey | {
-		type: string;
-	}): ResourceSchema | ObjectSchema;
-	registerResources(schemas: Array<ResourceSchema | ObjectSchema>): void;
-	registerResource(schema: ResourceSchema | ObjectSchema): void;
-	/**
-	* Registers a {@link Trait} for use by resource schemas.
-	*
-	* Traits are re-usable collections of fields that can be composed to
-	* build up a resource schema. Often they represent polymorphic behaviors
-	* a resource should exhibit.
-	*
-	* When we finalize a resource, we walk its traits and apply their fields
-	* to the resource's fields. All specified traits must be registered by
-	* this time or an error will be thrown.
-	*
-	* Traits are applied left-to-right, with traits of traits being applied in the same
-	* way. Thus for the most part, application of traits is a post-order graph traversal
-	* problem.
-	*
-	* A trait is only ever processed once. If multiple traits (A, B, C) have the same
-	* trait (D) as a dependency, D will be included only once when first encountered by
-	* A.
-	*
-	* If a cycle exists such that trait A has trait B which has Trait A, trait A will
-	* be applied *after* trait B in production. In development a cycle error will be thrown.
-	*
-	* Fields are finalized on a "last wins principle". Thus traits appearing higher in
-	* the tree and further to the right of a traits array take precedence, with the
-	* resource's fields always being applied last and winning out.
-	*
-	* @public
-	*/
-	registerTrait(trait: Trait): void;
-	registerTransformation<
-		T extends Value = string,
-		PT = unknown
-	>(transformation: Transformation<T, PT>): void;
-	registerDerivation<
-		R,
-		T,
-		FM extends ObjectValue | null
-	>(derivation: Derivation<R, T, FM>): void;
-	CAUTION_MEGA_DANGER_ZONE_registerExtension(extension: CAUTION_MEGA_DANGER_ZONE_Extension): void;
-	CAUTION_MEGA_DANGER_ZONE_resourceExtensions(resource: ResourceKey | {
-		type: string;
-	}): null | ProcessedExtension["features"];
-	CAUTION_MEGA_DANGER_ZONE_objectExtensions(field: ExtensibleField, resolvedType: string | null): null | ProcessedExtension["features"];
-	CAUTION_MEGA_DANGER_ZONE_arrayExtensions(field: ExtensibleField): null | ProcessedExtension["features"];
-	CAUTION_MEGA_DANGER_ZONE_hasExtension(ext: {
-		kind: "object" | "array";
-		name: string;
-	}): boolean;
-	/**
-	* Registers a {@link HashFn} for use with a {@link HashField} for
-	* either {@link ObjectSchema} identity or polymorphic type calculation.
-	*
-	* @public
-	*/
-	registerHashFn<T extends object>(hashFn: HashFn<T>): void;
-	fields({ type }: {
-		type: string;
-	}): InternalSchema["fields"];
-	cacheFields({ type }: {
-		type: string;
-	}): InternalSchema["cacheFields"];
-	hasResource(resource: {
-		type: string;
-	}): boolean;
-}
-export {};

package/declarations/reactive/-private/symbols.d.ts

@@ -1,5 +0,0 @@
-export declare const SOURCE: "___(unique) Symbol(SOURCE)";
-export declare const Destroy: "___(unique) Symbol(Destroy)";
-export declare const Checkout: "___(unique) Symbol(Checkout)";
-export declare const Commit: "___(unique) Symbol(Commit)";
-export declare const Context: "___(unique) Symbol(Context)";

package/declarations/request/-private/context.d.ts

@@ -1,39 +0,0 @@
-import type { RequestKey } from "../../types/identifier.js";
-import type { ImmutableHeaders, ImmutableRequestInfo, RequestInfo, ResponseInfo } from "../../types/request.js";
-import type { DeferredStream, GodContext } from "./types.js";
-export declare function upgradeHeaders(headers: Headers | ImmutableHeaders): ImmutableHeaders;
-export declare function cloneResponseProperties(response: Response): ResponseInfo;
-export declare class ContextOwner {
-	hasSetStream: boolean;
-	hasSetResponse: boolean;
-	hasSubscribers: boolean;
-	stream: DeferredStream;
-	response: ResponseInfo | null;
-	request: ImmutableRequestInfo;
-	enhancedRequest: ImmutableRequestInfo;
-	nextCalled: number;
-	god: GodContext;
-	controller: AbortController;
-	requestId: number;
-	isRoot: boolean;
-	constructor(request: RequestInfo, god: GodContext, isRoot?: boolean);
-	get hasRequestedStream(): boolean;
-	getResponse(): ResponseInfo | null;
-	getStream(): Promise<ReadableStream | null>;
-	abort(reason: DOMException): void;
-	setStream(stream: ReadableStream | Promise<ReadableStream | null> | null): void;
-	resolveStream(): void;
-	setResponse(response: ResponseInfo | Response | null): void;
-}
-export declare class Context {
-	request: ImmutableRequestInfo;
-	id: number;
-	constructor(owner: ContextOwner, isCacheHandler: boolean);
-	setStream(stream: ReadableStream | Promise<ReadableStream | null>): void;
-	setResponse(response: ResponseInfo | Response | null): void;
-	setIdentifier(identifier: RequestKey): void;
-	get hasRequestedStream(): boolean;
-	/** @private */
-	_finalize(): void;
-}
-export type HandlerRequestContext = Context;

package/declarations/request/-private/debug.d.ts

@@ -1,4 +0,0 @@
-import type { RequestInfo } from "../../types/request.js";
-import { Context } from "./context.js";
-export declare function deepFreeze<T = unknown>(value: T): T;
-export declare function assertValidRequest(request: RequestInfo | Context, isTopLevel: boolean): asserts request is RequestInfo;

package/declarations/request/-private/fetch.d.ts

@@ -1,33 +0,0 @@
-import { type Context } from "./context.js";
-import type { FetchError } from "./utils.js";
-export type { FetchError };
-interface FastbootRequest extends Request {
-	protocol: string;
-	host: string;
-}
-export interface FastBoot {
-	require(moduleName: string): unknown;
-	isFastBoot: boolean;
-	request: FastbootRequest;
-}
-/**
-* ```ts
-* import { Fetch } from '@warp-drive-mirror/core';
-* ```
-*
-* A basic Fetch Handler which converts a request into a
-* `fetch` call presuming the response to be `json`.
-*
-* ```ts
-* import { RequestManager, Fetch } from '@warp-drive-mirror/core';
-*
-* const manager = new RequestManager()
-*   .use([Fetch]);
-* ```
-*
-* @public
-*/
-declare const Fetch: {
-	request<T>(context: Context): Promise<T>;
-};
-export { Fetch };

package/declarations/request/-private/future.d.ts

@@ -1,7 +0,0 @@
-import { type StructuredDocument } from "../../types/request.js";
-import type { ContextOwner } from "./context.js";
-import type { Deferred, DeferredFuture, Future } from "./types.js";
-export declare function isFuture<T>(maybe: unknown): maybe is Future<T>;
-export declare function createDeferred<T>(): Deferred<T>;
-export declare function upgradePromise<T>(promise: Promise<StructuredDocument<T>>, future: Future<T>): Future<T>;
-export declare function createFuture<T>(owner: ContextOwner): DeferredFuture<T>;

package/declarations/request/-private/manager.d.ts

@@ -1,158 +0,0 @@
-import type { RequestKey } from "../../types/identifier.js";
-import { type RequestInfo } from "../../types/request.js";
-import type { CacheHandler, Future, GenericCreateArgs, Handler, ManagedRequestPriority } from "./types.js";
-import { IS_CACHE_HANDLER } from "./utils.js";
-/**
-* ## Import
-*
-* ```js
-* import { RequestManager } from '@warp-drive-mirror/core';
-* ```
-*
-* For complete usage guide see the [RequestManager Documentation](/guides/).
-*
-* ## How It Works
-*
-* ```ts
-* interface RequestManager {
-*   request<T>(req: RequestInfo): Future<T>;
-* }
-* ```
-*
-* A RequestManager provides a request/response flow in which configured
-* handlers are successively given the opportunity to handle, modify, or
-* pass-along a request.
-*
-* <img src="/images/handlers-all-labeled.gif" alt="RequestManager Flow Animation" width="100%" />
-*
-* For example:
-*
-* ::: code-group
-*
-* ```ts [Setup.ts]
-* import { RequestManager, Fetch } from '@warp-drive-mirror/core';
-* import { AutoCompress } from '@warp-drive-mirror/utilities/handlers';
-* import Auth from 'ember-simple-auth/handler';
-*
-* // ... create manager
-* const manager = new RequestManager()
-*    .use([Auth, new AutoCompress(), Fetch]); // [!code focus]
-* ```
-*
-* ```ts [Usage.ts]
-* import Config from './config';
-*
-* const { apiUrl } = Config;
-*
-* // ... execute a request
-* const response = await manager.request({
-*   url: `${apiUrl}/users`
-* });
-* ```
-*
-* :::
-*
-* ### Futures
-*
-* The return value of `manager.request` is a `Future`, which allows
-* access to limited information about the request while it is still
-* pending and fulfills with the final state when the request completes.
-*
-* A `Future` is cancellable via `abort`.
-*
-* Handlers may optionally expose a `ReadableStream` to the `Future` for
-* streaming data; however, when doing so the future should not resolve
-* until the response stream is fully read.
-*
-* ```ts
-* interface Future<T> extends Promise<StructuredDocument<T>> {
-*   abort(): void;
-*
-*   async getStream(): ReadableStream | null;
-* }
-* ```
-*
-* ### StructuredDocuments
-*
-* A Future resolves with a `StructuredDataDocument` or rejects with a `StructuredErrorDocument`.
-*
-* ```ts
-* interface StructuredDataDocument<T> {
-*   request: ImmutableRequestInfo;
-*   response: ImmutableResponseInfo;
-*   content: T;
-* }
-* interface StructuredErrorDocument extends Error {
-*   request: ImmutableRequestInfo;
-*   response: ImmutableResponseInfo;
-*   error: string | object;
-* }
-* type StructuredDocument<T> = StructuredDataDocument<T> | StructuredErrorDocument;
-* ```
-*
-* @public
-*/
-export declare class RequestManager {
-	constructor(options?: GenericCreateArgs);
-	/**
-	* Register a handler to use for primary cache intercept.
-	*
-	* Only one such handler may exist. If using the same
-	* RequestManager as the Store instance the Store
-	* registers itself as a Cache handler.
-	*
-	* @public
-	*/
-	useCache(cacheHandler: CacheHandler & {
-		[IS_CACHE_HANDLER]?: true;
-	}): this;
-	/**
-	* Register handler(s) to use when a request is issued.
-	*
-	* Handlers will be invoked in the order they are registered.
-	* Each Handler is given the opportunity to handle the request,
-	* curry the request, or pass along a modified request.
-	*
-	* @public
-	*/
-	use(newHandlers: Handler[]): this;
-	/**
-	* Issue a Request.
-	*
-	* Returns a Future that fulfills with a StructuredDocument
-	*
-	* @public
-	*/
-	request<RT>(request: RequestInfo<RT>): Future<RT>;
-	/**
-	* This method exists so that the RequestManager can be created
-	* can be created by container/factory systems that expect to
-	* call a static `create` method to instantiate the class.
-	*
-	* Using `new RequestManager()` directly is preferred.
-	*
-	* @private
-	*/
-	static create(options?: GenericCreateArgs): RequestManager;
-}
-/**
-* This type exists for internal use only for
-* where intimate contracts still exist either for
-* the Test Suite or for Legacy code.
-*
-* @private
-*/
-export interface PrivateRequestManager extends RequestManager {
-	/**
-	* A map of pending requests from request.id to their
-	* associated CacheHandler promise.
-	*
-	* This queue is managed by the CacheHandler
-	*
-	*/
-	_pending: Map<number, Promise<unknown>>;
-	_deduped: Map<RequestKey, {
-		priority: ManagedRequestPriority;
-		promise: Promise<unknown>;
-	}>;
-}

package/declarations/request/-private/promise-cache.d.ts

@@ -1,28 +0,0 @@
-export type CacheResult<
-	T = unknown,
-	E = unknown
-> = {
-	isError: true;
-	result: E;
-} | {
-	isError: false;
-	result: T;
-};
-export type Awaitable<
-	T = unknown,
-	E = unknown
-> = {
-	then: (onFulfilled: (value: T) => unknown, onRejected: (reason: E) => unknown) => unknown;
-	catch: (onRejected: (reason: E) => unknown) => unknown;
-	finally: (onFinally: () => unknown) => unknown;
-};
-export declare const PromiseCache: WeakMap<Awaitable, CacheResult>;
-export declare const RequestMap: Map<number, CacheResult>;
-export declare function setRequestResult(requestId: number, result: CacheResult): void;
-export declare function clearRequestResult(requestId: number): void;
-export declare function getRequestResult(requestId: number): CacheResult | undefined;
-export declare function setPromiseResult(promise: Promise<unknown> | Awaitable, result: CacheResult): void;
-export declare function getPromiseResult<
-	T,
-	E
->(promise: Promise<T> | Awaitable<T, E>): CacheResult<T, E> | undefined;