@warp-drive/legacy 5.6.0-alpha.15 → 5.6.0-alpha.18

package/declarations/model/-private/schema-provider.d.ts

@@ -1,63 +1,60 @@
-import type { Store } from '@warp-drive/core';
-import type { SchemaService } from '@warp-drive/core/types';
-import type { RecordIdentifier, StableRecordIdentifier } from '@warp-drive/core/types/identifier';
-import type { ObjectValue } from '@warp-drive/core/types/json/raw';
-import type { Derivation, HashFn, Transformation } from '@warp-drive/core/types/schema/concepts';
-import type { ArrayField, DerivedField, GenericField, HashField, LegacyAttributeField, LegacyField, LegacyRelationshipField, ObjectField, ObjectSchema, ResourceSchema } from '@warp-drive/core/types/schema/fields';
-import type { ModelFactory, ModelStore } from './model.ts';
-type AttributesSchema = ReturnType<Exclude<SchemaService['attributesDefinitionFor'], undefined>>;
-type RelationshipsSchema = ReturnType<Exclude<SchemaService['relationshipsDefinitionFor'], undefined>>;
-type InternalSchema = {
-    schema: ResourceSchema;
-    fields: Map<string, LegacyAttributeField | LegacyRelationshipField>;
-    attributes: Record<string, LegacyAttributeField>;
-    relationships: Record<string, LegacyRelationshipField>;
-};
+import type { Store } from "@warp-drive/core";
+import type { SchemaService } from "@warp-drive/core/types";
+import type { RecordIdentifier, StableRecordIdentifier } from "@warp-drive/core/types/identifier";
+import type { ObjectValue } from "@warp-drive/core/types/json/raw";
+import type { Derivation, HashFn, Transformation } from "@warp-drive/core/types/schema/concepts";
+import type { ArrayField, DerivedField, GenericField, HashField, LegacyField, ObjectField, ObjectSchema, ResourceSchema } from "@warp-drive/core/types/schema/fields";
+import type { ModelFactory, ModelStore } from "./model.js";
+type AttributesSchema = ReturnType<Exclude<SchemaService["attributesDefinitionFor"], undefined>>;
+type RelationshipsSchema = ReturnType<Exclude<SchemaService["relationshipsDefinitionFor"], undefined>>;
 export interface ModelSchemaProvider {
-    attributesDefinitionFor(resource: RecordIdentifier | {
-        type: string;
-    }): AttributesSchema;
-    relationshipsDefinitionFor(resource: RecordIdentifier | {
-        type: string;
-    }): RelationshipsSchema;
-    doesTypeExist(type: string): boolean;
+	attributesDefinitionFor(resource: RecordIdentifier | {
+		type: string;
+	}): AttributesSchema;
+	relationshipsDefinitionFor(resource: RecordIdentifier | {
+		type: string;
+	}): RelationshipsSchema;
+	doesTypeExist(type: string): boolean;
 }
 export declare class ModelSchemaProvider implements SchemaService {
-    store: ModelStore;
-    _schemas: Map<string, InternalSchema>;
-    _typeMisses: Set<string>;
-    constructor(store: ModelStore);
-    resourceTypes(): Readonly<string[]>;
-    hasTrait(type: string): boolean;
-    resourceHasTrait(resource: StableRecordIdentifier | {
-        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: StableRecordIdentifier | {
-        type: string;
-    }): ResourceSchema | ObjectSchema;
-    registerResources(schemas: Array<ResourceSchema | ObjectSchema>): void;
-    registerResource(schema: ResourceSchema | ObjectSchema): void;
-    registerTransformation(transform: Transformation): void;
-    registerDerivation<R, T, FM extends ObjectValue | null>(derivation: Derivation<R, T, FM>): void;
-    registerHashFn(hashFn: HashFn): void;
-    _loadModelSchema(type: string): InternalSchema;
-    fields(resource: RecordIdentifier | {
-        type: string;
-    }): Map<string, LegacyField>;
-    hasResource(resource: {
-        type: string;
-    }): boolean;
+	private store;
+	private _schemas;
+	private _typeMisses;
+	constructor(store: ModelStore);
+	resourceTypes(): Readonly<string[]>;
+	hasTrait(type: string): boolean;
+	resourceHasTrait(resource: StableRecordIdentifier | {
+		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: StableRecordIdentifier | {
+		type: string;
+	}): ResourceSchema | ObjectSchema;
+	registerResources(schemas: Array<ResourceSchema | ObjectSchema>): void;
+	registerResource(schema: ResourceSchema | ObjectSchema): void;
+	registerTransformation(transform: Transformation): void;
+	registerDerivation<
+		R,
+		T,
+		FM extends ObjectValue | null
+	>(derivation: Derivation<R, T, FM>): void;
+	registerHashFn(hashFn: HashFn): void;
+	private _loadModelSchema;
+	fields(resource: RecordIdentifier | {
+		type: string;
+	}): Map<string, LegacyField>;
+	hasResource(resource: {
+		type: string;
+	}): boolean;
 }
 export declare function buildSchema(store: Store): SchemaService;
 export declare function getModelFactory(store: ModelStore, type: string): ModelFactory | null;
 export {};
-//# sourceMappingURL=schema-provider.d.ts.map

package/declarations/model/-private/type-utils.d.ts

@@ -1,57 +1,57 @@
-import type { RelatedCollection } from '@warp-drive/core/store/-private';
-import type { TypedRecordInstance } from '@warp-drive/core/types/record';
-import type { Type } from '@warp-drive/core/types/symbols';
-import type { Model } from './model.ts';
-import type { PromiseBelongsTo } from './promise-belongs-to.ts';
-import type { PromiseManyArray } from './promise-many-array.ts';
+import type { RelatedCollection } from "@warp-drive/core/store/-private";
+import type { TypedRecordInstance } from "@warp-drive/core/types/record";
+import type { Type } from "@warp-drive/core/types/symbols";
+import type { Model } from "./model.js";
+import type { PromiseBelongsTo } from "./promise-belongs-to.js";
+import type { PromiseManyArray } from "./promise-many-array.js";
 type ExcludeNull<T> = Exclude<T, null> extends never ? T : Exclude<T, null>;
-type GetMappedKey<M, V> = {
-    [K in keyof M]-?: ExcludeNull<M[K]> extends V ? K : never;
-}[keyof M] & string;
+type GetMappedKey<
+	M,
+	V
+> = { [K in keyof M]-? : ExcludeNull<M[K]> extends V ? K : never }[keyof M] & string;
 /**
- * Get the keys of fields that are maybe defined as `belongsTo` relationships
- *
- * "Maybe" because getter/computed fields might be returning values that look
- * like relationships, but are not.
- *
- */
+* Get the keys of fields that are maybe defined as `belongsTo` relationships
+*
+* "Maybe" because getter/computed fields might be returning values that look
+* like relationships, but are not.
+*
+*/
 export type MaybeBelongsToFields<ThisType> = _TrueKeys<ThisType> extends never ? string : _MaybeBelongsToFields<ThisType>;
 export type _MaybeBelongsToFields<ThisType> = GetMappedKey<ThisType, PromiseBelongsTo | TypedRecordInstance>;
 /**
- * Get the keys of fields that are maybe defined as `hasMany` relationships
- *
- * "Maybe" because getter/computed fields might be returning values that look
- * like relationships, but are not.
- *
- */
+* Get the keys of fields that are maybe defined as `hasMany` relationships
+*
+* "Maybe" because getter/computed fields might be returning values that look
+* like relationships, but are not.
+*
+*/
 export type MaybeHasManyFields<ThisType> = _TrueKeys<ThisType> extends never ? string : _MaybeHasManyFields<ThisType>;
 type _MaybeHasManyFields<ThisType> = GetMappedKey<ThisType, RelatedCollection | PromiseManyArray>;
 /**
- * Get the keys of fields that are maybe defined as `attr` fields
- *
- * "Maybe" because getter/computed fields might be returning values that look
- * like attributes, but are not.
- *
- * This is computed by excluding the keys that are defined as `belongsTo` or `hasMany`
- * as well as the keys on EmberObject and the Model base class
- *
- */
+* Get the keys of fields that are maybe defined as `attr` fields
+*
+* "Maybe" because getter/computed fields might be returning values that look
+* like attributes, but are not.
+*
+* This is computed by excluding the keys that are defined as `belongsTo` or `hasMany`
+* as well as the keys on EmberObject and the Model base class
+*
+*/
 export type MaybeAttrFields<ThisType> = Exclude<_TrueKeys<ThisType>, _MaybeBelongsToFields<ThisType> | _MaybeHasManyFields<ThisType>>;
 /**
- * Get the keys of fields that are maybe defined as relationships
- *
- * "Maybe" because getter/computed fields might be returning values that look
- * like relationships, but are not.
- *
- */
+* Get the keys of fields that are maybe defined as relationships
+*
+* "Maybe" because getter/computed fields might be returning values that look
+* like relationships, but are not.
+*
+*/
 export type MaybeRelationshipFields<ThisType> = _TrueKeys<ThisType> extends never ? string : _MaybeBelongsToFields<ThisType> | _MaybeHasManyFields<ThisType>;
 type _TrueKeys<ThisType> = Exclude<keyof ThisType & string, (keyof Model & string) | typeof Type>;
 export type isSubClass<ThisType> = _TrueKeys<ThisType> extends never ? false : true;
 /**
- * Get the keys of all fields defined on the given subclass of Model
- * that don't exist on EmberObject or Model.
- *
- */
+* Get the keys of all fields defined on the given subclass of Model
+* that don't exist on EmberObject or Model.
+*
+*/
 export type SubclassKeys<ThisType> = _TrueKeys<ThisType> extends never ? string : _TrueKeys<ThisType>;
 export {};
-//# sourceMappingURL=type-utils.d.ts.map

package/declarations/model/-private/util.d.ts

@@ -1,6 +1,5 @@
 export type DecoratorPropertyDescriptor = (PropertyDescriptor & {
-    initializer?: () => unknown;
+	initializer?: () => unknown;
 }) | undefined;
 export declare function isElementDescriptor(args: unknown[]): args is [object, string, DecoratorPropertyDescriptor];
 export declare function normalizeModelName(type: string): string;
-//# sourceMappingURL=util.d.ts.map

package/declarations/model/-private.d.ts

@@ -1,8 +1,8 @@
-export { type MinimalLegacyRecord } from './-private/model-methods.ts';
-export type { ModelStore } from './-private/model.ts';
-export { Errors } from './-private/errors.ts';
-export { RelatedCollection as ManyArray } from '@warp-drive/core/store/-private';
-export { PromiseBelongsTo } from './-private/promise-belongs-to.ts';
-export { PromiseManyArray } from './-private/promise-many-array.ts';
-export { lookupLegacySupport, LEGACY_SUPPORT } from './-private/legacy-relationships-support.ts';
-//# sourceMappingURL=-private.d.ts.map
+export { type MinimalLegacyRecord } from "./-private/model-methods.js";
+export type { ModelStore } from "./-private/model.js";
+export { Errors } from "./-private/errors.js";
+export { RelatedCollection as ManyArray } from "@warp-drive/core/store/-private";
+export { PromiseBelongsTo } from "./-private/promise-belongs-to.js";
+export { PromiseManyArray } from "./-private/promise-many-array.js";
+// // Used by tests, migration support
+export { lookupLegacySupport, LEGACY_SUPPORT } from "./-private/legacy-relationships-support.js";