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

package/declarations/compat/utils.d.ts

@@ -1,138 +1,137 @@
-type Reporter = (type: 'formatted-id' | 'formatted-type', actual: unknown, expected: unknown) => void;
+type Reporter = (type: "formatted-id" | "formatted-type", actual: unknown, expected: unknown) => void;
 /**
- * Configure a function to be called when an id or type
- * changes during normalization. This is useful for instrumenting
- * to discover places where usage in the app is not consistent.
- *
- * @param method a function which takes a mismatch-type ('formatted-id' | 'formatted-type'), actual, and expected value
- * @public
- */
+* Configure a function to be called when an id or type
+* changes during normalization. This is useful for instrumenting
+* to discover places where usage in the app is not consistent.
+*
+* @param method a function which takes a mismatch-type ('formatted-id' | 'formatted-type'), actual, and expected value
+* @public
+*/
 export declare function configureMismatchReporter(fn: Reporter): void;
 /**
- * Configure a function to be called when an id or type
- * fails validation. This is useful for instrumenting
- * to discover places where usage in the app is not consistent.
- *
- * @param method a function which takes a message and a condition
- * @public
- */
+* Configure a function to be called when an id or type
+* fails validation. This is useful for instrumenting
+* to discover places where usage in the app is not consistent.
+*
+* @param method a function which takes a message and a condition
+* @public
+*/
 export declare function configureAssertFn(fn: (message: string, condition: unknown) => void): void;
 /**
- * Configure a function to be called to normalize
- * a resource type string. Used by both formattedType
- * and isEquivType to ensure consistent normalization
- * during comparison.
- *
- * If validation fails or the type turns out be unnormalized
- * the configured mismatch reporter and assert functions will
- * be called.
- *
- * @param method a function which takes a string and returns a string
- * @public
- */
+* Configure a function to be called to normalize
+* a resource type string. Used by both formattedType
+* and isEquivType to ensure consistent normalization
+* during comparison.
+*
+* If validation fails or the type turns out be unnormalized
+* the configured mismatch reporter and assert functions will
+* be called.
+*
+* @param method a function which takes a string and returns a string
+* @public
+*/
 export declare function configureTypeNormalization(fn: (type: string) => string): void;
 /**
- * Converts a potentially unnormalized type into the format expected
- * by our EmberData Cache. Currently this is singular-dasherized.
- *
- * you should not rely on this function to give you an exact format
- * for display purposes. Formatting for display should be handled
- * differently if the exact format matters.
- *
- * Asserts invalid types (undefined, null, '') in dev.
- *
- * **Usage**
- *
- * ```js
- * import formattedType from 'soxhub-client/helpers/formatted-type';
- *
- * formattedType('post'); // => 'post'
- * formattedType('posts'); // => 'post'
- * formattedType('Posts'); // => 'post'
- * formattedType('post-comment'); // => 'post-comment'
- * formattedType('post-comments'); // => 'post-comment'
- * formattedType('post_comment'); // => 'post-comment'
- * formattedType('postComment'); // => 'post-comment'
- * formattedType('PostComment'); // => 'post-comment'
- * ```
- *
- * @param {String} type the potentially un-normalized type
- * @return {String} the normalized type
- * @public
- */
+* Converts a potentially unnormalized type into the format expected
+* by our EmberData Cache. Currently this is singular-dasherized.
+*
+* you should not rely on this function to give you an exact format
+* for display purposes. Formatting for display should be handled
+* differently if the exact format matters.
+*
+* Asserts invalid types (undefined, null, '') in dev.
+*
+* **Usage**
+*
+* ```js
+* import formattedType from 'soxhub-client/helpers/formatted-type';
+*
+* formattedType('post'); // => 'post'
+* formattedType('posts'); // => 'post'
+* formattedType('Posts'); // => 'post'
+* formattedType('post-comment'); // => 'post-comment'
+* formattedType('post-comments'); // => 'post-comment'
+* formattedType('post_comment'); // => 'post-comment'
+* formattedType('postComment'); // => 'post-comment'
+* formattedType('PostComment'); // => 'post-comment'
+* ```
+*
+* @param {String} type the potentially un-normalized type
+* @return {String} the normalized type
+* @public
+*/
 export declare function formattedType<T extends string>(type: T | string): T;
 /**
- * Format an id to the format expected by the EmberData Cache.
- * Currently this means that id should be `string | null`.
- *
- * Asserts invalid IDs (undefined, '', 0, '0') in dev.
- *
- * **Usage**
- *
- * ```js
- * import formattedId from 'client/utils/formatted-id';
- *
- * formattedId('1'); // => '1'
- * formattedId(1); // => '1'
- * formattedId(null); // => null
- *	```
- *
- * @param {String | Number | null} id the potentially un-normalized id
- * @return {String | null} the normalized id
- * @public
- */
+* Format an id to the format expected by the EmberData Cache.
+* Currently this means that id should be `string | null`.
+*
+* Asserts invalid IDs (undefined, '', 0, '0') in dev.
+*
+* **Usage**
+*
+* ```js
+* import formattedId from 'client/utils/formatted-id';
+*
+* formattedId('1'); // => '1'
+* formattedId(1); // => '1'
+* formattedId(null); // => null
+*	```
+*
+* @param {String | Number | null} id the potentially un-normalized id
+* @return {String | null} the normalized id
+* @public
+*/
 export declare function formattedId(id: string | number): string;
 export declare function formattedId(id: null): null;
 export declare function formattedId(id: string | number | null): string | null;
 export declare function expectId(id: string | number): string;
 export declare function expectId(id: null): never;
 /**
- * Compares two types for strict equality, converting them to
- * the format expected by the EmberData Cache to ensure
- * differences in format are accounted for in the comparison.
- *
- * Asserts when expected or actual are invalid types in dev.
- * Expected may never be null.
- *
- * ```js
- * isEquivType('posts', 'post'); // true
- * isEquivType('post', 'post'); // true
- * isEquivType('posts', 'posts'); // true
- * isEquivType('post-comment', 'postComment'); // true
- * isEquivType('post-comment', 'PostComment'); // true
- * isEquivType('post-comment', 'post_comment'); // true
- * isEquivType('post-comment', 'post-comment'); // true
- * isEquivType('post-comment', 'post'); // false
- * isEquivType('posts', null); // false
- * ```
- *
- * @param {String} expected a potentially unnormalized type to match against
- * @param {String} actual a potentially unnormalized type to match against
- * @return {Boolean} true if the types are equivalent
- * @public
- */
+* Compares two types for strict equality, converting them to
+* the format expected by the EmberData Cache to ensure
+* differences in format are accounted for in the comparison.
+*
+* Asserts when expected or actual are invalid types in dev.
+* Expected may never be null.
+*
+* ```js
+* isEquivType('posts', 'post'); // true
+* isEquivType('post', 'post'); // true
+* isEquivType('posts', 'posts'); // true
+* isEquivType('post-comment', 'postComment'); // true
+* isEquivType('post-comment', 'PostComment'); // true
+* isEquivType('post-comment', 'post_comment'); // true
+* isEquivType('post-comment', 'post-comment'); // true
+* isEquivType('post-comment', 'post'); // false
+* isEquivType('posts', null); // false
+* ```
+*
+* @param {String} expected a potentially unnormalized type to match against
+* @param {String} actual a potentially unnormalized type to match against
+* @return {Boolean} true if the types are equivalent
+* @public
+*/
 export declare function isEquivType(expected: string, actual: string): boolean;
 /**
- * Compares two IDs for strict equality, converting them to
- * the format expected by the EmberData Cache to ensure
- * differences in format are accounted for in the comparison.
- *
- * Asserts when expected or actual are invalid IDs in dev.
- * Expected may never be null.
- *
- * ```js
- * isEquivId('1', 1); // true
- * isEquivId('2', '2'); // true
- * isEquivId(3, '3'); // true
- * isEquivId(4, '3'); // false
- * isEquivId(1, null); // false
- * ```
- *
- * @param {string | number} expected a potentially un-normalized id to match against
- * @param {string | number} actual a potentially un-normalized id to match against
- * @return {Boolean} true if the ids are equivalent
- * @public
- */
+* Compares two IDs for strict equality, converting them to
+* the format expected by the EmberData Cache to ensure
+* differences in format are accounted for in the comparison.
+*
+* Asserts when expected or actual are invalid IDs in dev.
+* Expected may never be null.
+*
+* ```js
+* isEquivId('1', 1); // true
+* isEquivId('2', '2'); // true
+* isEquivId(3, '3'); // true
+* isEquivId(4, '3'); // false
+* isEquivId(1, null); // false
+* ```
+*
+* @param {string | number} expected a potentially un-normalized id to match against
+* @param {string | number} actual a potentially un-normalized id to match against
+* @return {Boolean} true if the ids are equivalent
+* @public
+*/
 export declare function isEquivId(expected: string | number, actual: string | number | null): boolean;
 export {};
-//# sourceMappingURL=utils.d.ts.map

package/declarations/compat.d.ts

@@ -1,134 +1,136 @@
-import { type Store } from '@warp-drive/core';
-import type { ObjectValue } from '@warp-drive/core/types/json/raw';
-import { FetchManager } from './compat/-private.ts';
-import type { AdapterPayload, MinimumAdapterInterface } from './compat/legacy-network-handler/minimum-adapter-interface.ts';
-import type { MinimumSerializerInterface, SerializerOptions } from './compat/legacy-network-handler/minimum-serializer-interface.ts';
-export { LegacyNetworkHandler } from './compat/legacy-network-handler/legacy-network-handler.ts';
+import { type Store } from "@warp-drive/core";
+import type { ObjectValue } from "@warp-drive/core/types/json/raw";
+import type { SingleResourceDocument } from "@warp-drive/core/types/spec/json-api-raw";
+import { FetchManager } from "./compat/-private.js";
+import type { AdapterPayload, MinimumAdapterInterface } from "./compat/legacy-network-handler/minimum-adapter-interface.js";
+import type { MinimumSerializerInterface, SerializerOptions } from "./compat/legacy-network-handler/minimum-serializer-interface.js";
+export { LegacyNetworkHandler } from "./compat/legacy-network-handler/legacy-network-handler.js";
 export type { MinimumAdapterInterface, MinimumSerializerInterface, SerializerOptions, AdapterPayload };
 export type LegacyStoreCompat = {
-    _fetchManager: FetchManager;
-    adapterFor(this: Store, modelName: string): MinimumAdapterInterface;
-    adapterFor(this: Store, modelName: string, _allowMissing: true): MinimumAdapterInterface | undefined;
-    serializerFor<K extends string>(modelName: K, _allowMissing?: boolean): MinimumSerializerInterface | null;
-    normalize(modelName: string, payload: ObjectValue): ObjectValue;
-    pushPayload(modelName: string, payload: ObjectValue): void;
-    serializeRecord(record: unknown, options?: SerializerOptions): unknown;
-    _adapterCache: Record<string, MinimumAdapterInterface & {
-        store: Store;
-    }>;
-    _serializerCache: Record<string, MinimumSerializerInterface & {
-        store: Store;
-    }>;
+	_fetchManager: FetchManager;
+	adapterFor(this: Store, modelName: string): MinimumAdapterInterface;
+	adapterFor(this: Store, modelName: string, _allowMissing: true): MinimumAdapterInterface | undefined;
+	serializerFor<K extends string>(modelName: K, _allowMissing?: boolean): MinimumSerializerInterface | null;
+	normalize(modelName: string, payload: ObjectValue): ObjectValue;
+	pushPayload(modelName: string, payload: ObjectValue): void;
+	serializeRecord(record: unknown, options?: SerializerOptions): unknown;
+	_adapterCache: Record<string, MinimumAdapterInterface & {
+		store: Store;
+	}>;
+	_serializerCache: Record<string, MinimumSerializerInterface & {
+		store: Store;
+	}>;
 };
 export type CompatStore = Store & LegacyStoreCompat;
 /**
-    Returns an instance of the adapter for a given type. For
-    example, `adapterFor('person')` will return an instance of
-    the adapter located at `app/adapters/person.js`
-
-    If no `person` adapter is found, this method will look
-    for an `application` adapter (the default adapter for
-    your entire application).
-
-    @public
-    @param {String} modelName
-    @return {Adapter}
-  */
+Returns an instance of the adapter for a given type. For
+example, `adapterFor('person')` will return an instance of
+the adapter located at `app/adapters/person.js`
+
+If no `person` adapter is found, this method will look
+for an `application` adapter (the default adapter for
+your entire application).
+
+@public
+@param {String} modelName
+@return {Adapter}
+*/
 export declare function adapterFor(this: Store, modelName: string): MinimumAdapterInterface;
 export declare function adapterFor(this: Store, modelName: string, _allowMissing: true): MinimumAdapterInterface | undefined;
 /**
-    Returns an instance of the serializer for a given type. For
-    example, `serializerFor('person')` will return an instance of
-    `App.PersonSerializer`.
+Returns an instance of the serializer for a given type. For
+example, `serializerFor('person')` will return an instance of
+`App.PersonSerializer`.
 
-    If no `App.PersonSerializer` is found, this method will look
-    for an `App.ApplicationSerializer` (the default serializer for
-    your entire application).
+If no `App.PersonSerializer` is found, this method will look
+for an `App.ApplicationSerializer` (the default serializer for
+your entire application).
 
-    If a serializer cannot be found on the adapter, it will fall back
-    to an instance of `JSONSerializer`.
+If a serializer cannot be found on the adapter, it will fall back
+to an instance of `JSONSerializer`.
 
-    @public
-    @param {String} modelName the record to serialize
-    @return {Serializer}
-  */
+@public
+@param {String} modelName the record to serialize
+@return {Serializer}
+*/
 export declare function serializerFor(this: Store, modelName: string): MinimumSerializerInterface | null;
 /**
-    `normalize` converts a json payload into the normalized form that
-    [push](../methods/push?anchor=push) expects.
-
-    Example
-
-    ```js
-    socket.on('message', function(message) {
-      let modelName = message.model;
-      let data = message.data;
-      store.push(store.normalize(modelName, data));
-    });
-    ```
-
-    @public
-    @param {String} modelName The name of the model type for this payload
-    @param {Object} payload
-    @return {Object} The normalized payload
-  */
-export declare function normalize(this: Store, modelName: string, payload: ObjectValue): import("@warp-drive/core/types/spec/json-api-raw.js").SingleResourceDocument;
+`normalize` converts a json payload into the normalized form that
+[push](../methods/push?anchor=push) expects.
+
+Example
+
+```js
+socket.on('message', function(message) {
+let modelName = message.model;
+let data = message.data;
+store.push(store.normalize(modelName, data));
+});
+```
+
+@public
+@param modelName The name of the model type for this payload
+@return The normalized payload
+*/
+// TODO @runspired @deprecate users should call normalize on the associated serializer directly
+export declare function normalize(this: Store, modelName: string, payload: ObjectValue): SingleResourceDocument;
 /**
-    Push some raw data into the store.
+Push some raw data into the store.
 
-    This method can be used both to push in brand new
-    records, as well as to update existing records. You
-    can push in more than one type of object at once.
-    All objects should be in the format expected by the
-    serializer.
+This method can be used both to push in brand new
+records, as well as to update existing records. You
+can push in more than one type of object at once.
+All objects should be in the format expected by the
+serializer.
 
-    ```js [app/serializers/application.js]
-    import RESTSerializer from '@ember-data/serializer/rest';
+```js [app/serializers/application.js]
+import RESTSerializer from '@ember-data/serializer/rest';
 
-    export default class ApplicationSerializer extends RESTSerializer;
-    ```
+export default class ApplicationSerializer extends RESTSerializer;
+```
 
-    ```js
-    let pushData = {
-      posts: [
-        { id: 1, postTitle: "Great post", commentIds: [2] }
-      ],
-      comments: [
-        { id: 2, commentBody: "Insightful comment" }
-      ]
-    }
+```js
+let pushData = {
+posts: [
+{ id: 1, postTitle: "Great post", commentIds: [2] }
+],
+comments: [
+{ id: 2, commentBody: "Insightful comment" }
+]
+}
 
-    store.pushPayload(pushData);
-    ```
+store.pushPayload(pushData);
+```
 
-    By default, the data will be deserialized using a default
-    serializer (the application serializer if it exists).
+By default, the data will be deserialized using a default
+serializer (the application serializer if it exists).
 
-    Alternatively, `pushPayload` will accept a model type which
-    will determine which serializer will process the payload.
+Alternatively, `pushPayload` will accept a model type which
+will determine which serializer will process the payload.
 
-    ```js [app/serializers/application.js]
-    import RESTSerializer from '@ember-data/serializer/rest';
+```js [app/serializers/application.js]
+import RESTSerializer from '@ember-data/serializer/rest';
 
-     export default class ApplicationSerializer extends RESTSerializer;
-    ```
+export default class ApplicationSerializer extends RESTSerializer;
+```
 
-    ```js [app/serializers/post.js]
-    import JSONSerializer from '@ember-data/serializer/json';
+```js [app/serializers/post.js]
+import JSONSerializer from '@ember-data/serializer/json';
 
-    export default JSONSerializer;
-    ```
+export default JSONSerializer;
+```
 
-    ```js
-    store.pushPayload(pushData); // Will use the application serializer
-    store.pushPayload('post', pushData); // Will use the post serializer
-    ```
+```js
+store.pushPayload(pushData); // Will use the application serializer
+store.pushPayload('post', pushData); // Will use the post serializer
+```
 
-    @public
-    @param {String} modelName Optionally, a model type used to determine which serializer will be used
-    @param {Object} inputPayload
-  */
+@public
+@param {String} modelName Optionally, a model type used to determine which serializer will be used
+@param {Object} inputPayload
+*/
+// TODO @runspired @deprecate pushPayload in favor of looking up the serializer
 export declare function pushPayload(this: Store, modelName: string, inputPayload: ObjectValue): void;
+// TODO @runspired @deprecate records should implement their own serialization if desired
 export declare function serializeRecord(this: Store, record: unknown, options?: SerializerOptions): unknown;
 export declare function cleanup(this: Store): void;
-//# sourceMappingURL=compat.d.ts.map